-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "GeometryGUI.h"
#include "GeometryGUI_Operations.h"
#include "GEOMPluginGUI.h"
-#include "GEOMGUI_XmlHandler.h"
#include "GEOMGUI_OCCSelector.h"
#include "GEOMGUI_Selection.h"
#include "GEOMGUI_CreationInfoWdg.h"
+#include "GEOMGUI_TextTreeWdg.h"
#include "GEOMGUI_DimensionProperty.h"
#include "GEOM_Constants.h"
#include "GEOM_Displayer.h"
#include "GEOM_AISShape.hxx"
+#include "GEOMUtils_XmlHandler.hxx"
+#include "GEOMGUI_AnnotationMgr.h"
+#include "GEOMGUI_TextTreeSelector.h"
#include "GEOM_Actor.h"
#include <SUIT_Session.h>
#include <SUIT_ViewManager.h>
-#include <PyInterp_Interp.h>
-
#include <OCCViewer_ViewWindow.h>
#include <OCCViewer_ViewPort3d.h>
#include <OCCViewer_ViewModel.h>
#include <SVTK_InteractorStyle.h>
#include <SVTK_ViewModel.h>
+#ifndef DISABLE_GRAPHICSVIEW
+#include <GraphicsView_Viewer.h>
+#endif
+
#include <SalomeApp_Application.h>
#include <SalomeApp_DataObject.h>
#include <SalomeApp_Study.h>
#include <LightApp_DataObject.h>
#include <LightApp_Preferences.h>
-#include <GraphicsView_Viewer.h>
-#include <DependencyTree_View.h>
-#include <DependencyTree_ViewModel.h>
-
#include <SALOME_LifeCycleCORBA.hxx>
-// #include <SALOME_ListIO.hxx>
-#include <SALOME_ListIteratorOfListIO.hxx>
+#include <SALOME_ListIO.hxx>
#include <SALOMEDSClient_ClientFactory.hxx>
#include <SALOMEDSClient_IParameters.hxx>
#include <SALOMEDS_SObject.hxx>
-#include <Basics_OCCTVersion.hxx>
+#include <QtxFontEdit.h>
// External includes
#include <QDir>
#include <QString>
#include <QPainter>
#include <QSignalMapper>
+#include <QFontDatabase>
-#include <AIS_Drawer.hxx>
#include <AIS_ListOfInteractive.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
#include <Prs3d_Drawer.hxx>
#include <OSD_SharedLibrary.hxx>
#include <NCollection_DataMap.hxx>
-#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
#include <TColStd_HArray1OfByte.hxx>
-#else
-#include <Graphic3d_HArray1OfBytes.hxx>
-#endif
+#include <TColStd_SequenceOfHAsciiString.hxx>
#include <utilities.h>
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx>
+#include <Font_SystemFont.hxx>
+#include <Font_FontMgr.hxx>
+#include <TCollection_HAsciiString.hxx>
+
#include "GEOM_version.h"
#include "GEOMImpl_Types.hxx" // dangerous hxx (defines short-name macros) - include after all
anObj = anORB->string_to_object(aValue.c_str());
}
} catch(...) {
- INFOS("ClientSObjectToObject - Unknown exception was occured!!!");
+ INFOS("ClientSObjectToObject - Unknown exception has occurred!!!");
}
return anObj._retn();
}
myLocalSelectionMode = GEOM_ALLOBJECTS;
myCreationInfoWdg = 0;
+ myTextTreeWdg = 0;
+ myAnnotationMgr = 0;
- connect( Material_ResourceMgr::resourceMgr(), SIGNAL( changed() ), this, SLOT( updateMaterials() ) );
+ connect( Material_ResourceMgr::resourceMgr(), SIGNAL( changed() ), this, SLOT( updateMaterials() ), Qt::UniqueConnection );
Q_INIT_RESOURCE( GEOMGUI );
}
{
if ( !myGUIMap.contains( libraryName ) ) {
// try to load library if it is not loaded yet
-#ifndef WIN32
- QString dirs = getenv( "LD_LIBRARY_PATH" );
- QString sep = ":";
-#else
+#if defined(WIN32)
QString dirs = getenv( "PATH" );
+#elif defined(__APPLE__)
+ QString dirs = getenv( "DYLD_LIBRARY_PATH" );
+#else
+ QString dirs = getenv( "LD_LIBRARY_PATH" );
+#endif
+#if defined(WIN32)
QString sep = ";";
+#else
+ QString sep = ":";
#endif
+
if ( !dirs.isEmpty() ) {
QStringList dirList = dirs.split(sep, QString::SkipEmptyParts ); // skip empty entries
QListIterator<QString> it( dirList ); it.toBack();
{
if ( !myGUIMap.contains( libraryName ) ) {
// try to load library if it is not loaded yet
-#ifndef WIN32
- QString dirs = getenv( "LD_LIBRARY_PATH" );
- QString sep = ":";
-#else
+
+#if defined(WIN32)
QString dirs = getenv( "PATH" );
+#elif defined(__APPLE__)
+ QString dirs = getenv( "DYLD_LIBRARY_PATH" );
+#else
+ QString dirs = getenv( "LD_LIBRARY_PATH" );
+#endif
+#if defined(WIN32)
QString sep = ";";
+#else
+ QString sep = ":";
#endif
+
if ( !dirs.isEmpty() ) {
QStringList dirList = dirs.split(sep, QString::SkipEmptyParts ); // skip empty entries
QListIterator<QString> it( dirList ); it.toBack();
}
}
+//=======================================================================
+// function : GeometryGUI::SetActiveDialogBox()
+// purpose : Set active dialog box
+//=======================================================================
+GEOMGUI_AnnotationMgr* GeometryGUI::GetAnnotationMgr()
+{
+ if ( !myAnnotationMgr )
+ myAnnotationMgr = new GEOMGUI_AnnotationMgr( getApp() );
+ return myAnnotationMgr;
+}
+
+//=======================================================================
+// function : GeometryGUI::SetActiveDialogBox()
+// purpose : Set active dialog box
+//=======================================================================
+GEOMGUI_TextTreeWdg* GeometryGUI::GetTextTreeWdg() const
+{
+ return myTextTreeWdg;
+}
+
//=======================================================================
// function : GeometryGUI::SetActiveDialogBox()
// purpose : Set active dialog box
SUIT_ViewWindow* window = desk->activeWindow();
bool ViewOCC = ( window && window->getViewManager()->getType() == OCCViewer_Viewer::Type() );
bool ViewVTK = ( window && window->getViewManager()->getType() == SVTK_Viewer::Type() );
+#ifndef DISABLE_GRAPHICSVIEW
+ bool ViewDep = ( window && window->getViewManager()->getType() == GraphicsView_Viewer::Type() );
+#else
+ bool ViewDep = 0;
+#endif
// 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<int> NotViewerDependentCommands;
<< GEOMOp::OpPointMarker
<< GEOMOp::OpCreateFolder
<< GEOMOp::OpSortChildren;
- if ( !ViewOCC && !ViewVTK && !NotViewerDependentCommands.contains( id ) ) {
+ if ( !ViewOCC && !ViewVTK && !ViewDep && !NotViewerDependentCommands.contains( id ) ) {
// activate OCC viewer
getApp()->getViewManager(OCCViewer_Viewer::Type(), /*create=*/true);
}
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::OpSelectCompound: // POPUP MENU - SELECT ONLY - COMPOUND
case GEOMOp::OpSelectAll: // POPUP MENU - SELECT ONLY - SELECT ALL
case GEOMOp::OpDelete: // MENU EDIT - DELETE
+#ifndef DISABLE_PYCONSOLE
case GEOMOp::OpCheckGeom: // MENU TOOLS - CHECK GEOMETRY
+#endif
case GEOMOp::OpMaterialsLibrary: // MENU TOOLS - MATERIALS LIBRARY
case GEOMOp::OpDeflection: // POPUP MENU - DEFLECTION COEFFICIENT
case GEOMOp::OpColor: // POPUP MENU - COLOR
case GEOMOp::OpClsBringToFront: //
case GEOMOp::OpCreateFolder: // POPUP MENU - CREATE FOLDER
case GEOMOp::OpSortChildren: // POPUP MENU - SORT CHILD ITEMS
+#ifndef DISABLE_GRAPHICSVIEW
case GEOMOp::OpShowDependencyTree: // POPUP MENU - SHOW DEPENDENCY TREE
+#endif
+ case GEOMOp::OpReduceStudy: // POPUP MENU - REDUCE STUDY
libName = "GEOMToolsGUI";
break;
case GEOMOp::OpDMWireframe: // MENU VIEW - WIREFRAME
case GEOMOp::OpHide: // MENU VIEW - ERASE
case GEOMOp::OpShow: // MENU VIEW - DISPLAY
case GEOMOp::OpSwitchVectors: // MENU VIEW - VECTOR MODE
+ case GEOMOp::OpSwitchVertices: // MENU VIEW - VERTICES MODE
+ case GEOMOp::OpSwitchName: // MENU VIEW - VERTICES 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
+ case GEOMOp::OpVertices: // POPUP MENU - VERTICES
+ case GEOMOp::OpShowName: // POPUP MENU - SHOW NAME
libName = "DisplayGUI";
break;
case GEOMOp::OpPoint: // MENU BASIC - POINT
case GEOMOp::OpFilling: // MENU GENERATION - FILLING
case GEOMOp::OpPipe: // MENU GENERATION - PIPE
case GEOMOp::OpPipePath: // MENU GENERATION - RESTORE PATH
+ case GEOMOp::OpThickness: // MENU GENERATION - THICKNESS
libName = "GenerationGUI";
break;
case GEOMOp::Op2dSketcher: // MENU ENTITY - SKETCHER
case GEOMOp::Op3dSketcher: // MENU ENTITY - 3D SKETCHER
case GEOMOp::OpIsoline: // MENU BASIC - ISOLINE
case GEOMOp::OpExplode: // MENU ENTITY - EXPLODE
+ case GEOMOp::OpSurfaceFromFace: // MENU ENTITY - SURFACE FROM FACE
#ifdef WITH_OPENCV
case GEOMOp::OpFeatureDetect: // MENU ENTITY - FEATURE DETECTION
#endif
case GEOMOp::OpCreateField: // MENU FIELD - CREATE FIELD
case GEOMOp::OpEditField: // MENU FIELD - EDIT FIELD
case GEOMOp::OpEditFieldPopup: // POPUP MENU - EDIT FIELD
+ case GEOMOp::Op2dPolylineEditor: // MENU BASIC - POLYLINE EDITOR
libName = "EntityGUI";
break;
case GEOMOp::OpEdge: // MENU BUILD - EDGE
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::OpCompound: // MENU BUILD - COMPOUND
libName = "BuildGUI";
break;
case GEOMOp::OpFuse: // MENU BOOLEAN - FUSE
case GEOMOp::OpScale: // MENU TRANSFORMATION - SCALE
case GEOMOp::OpOffset: // MENU TRANSFORMATION - OFFSET
case GEOMOp::OpProjection: // MENU TRANSFORMATION - PROJECTION
+ case GEOMOp::OpProjOnCyl: // MENU TRANSFORMATION - PROJECTION ON CYLINDER
case GEOMOp::OpMultiTranslate: // MENU TRANSFORMATION - MULTI-TRANSLATION
case GEOMOp::OpMultiRotate: // MENU TRANSFORMATION - MULTI-ROTATION
case GEOMOp::OpReimport: // CONTEXT(POPUP) MENU - RELOAD_IMPORTED
+ case GEOMOp::OpExtension: // MENU TRANSFORMATION - EXTENSION
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::OpSharedShapes: // MENU OPERATION - GET SHARED SHAPES
case GEOMOp::OpExtrudedBoss: // MENU OPERATION - EXTRUDED BOSS
case GEOMOp::OpExtrudedCut: // MENU OPERATION - EXTRUDED CUT
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- case GEOMOp::OpCurveCreator: // MENU OPERATION - CURVE CREATOR
-#endif
+ case GEOMOp::OpTransferData: // MENU OPERATION - TRANSFER DATA
+ case GEOMOp::OpExtraction: // MENU OPERATION - EXTRACT AND REBUILD
libName = "OperationGUI";
break;
case GEOMOp::OpSewing: // MENU REPAIR - SEWING
case GEOMOp::OpRemoveExtraEdges: // MENU REPAIR - REMOVE EXTRA EDGES
case GEOMOp::OpFuseEdges: // MENU REPAIR - FUSE COLLINEAR EDGES
case GEOMOp::OpUnionFaces: // MENU REPAIR - UNION FACES
+ case GEOMOp::OpInspectObj: // MENU REPAIR - INSPECT OBJECT
libName = "RepairGUI";
break;
case GEOMOp::OpProperties: // MENU MEASURE - PROPERTIES
case GEOMOp::OpGetNonBlocks: // MENU MEASURE - Get NON BLOCKS
case GEOMOp::OpPointCoordinates: // MENU MEASURE - POINT COORDINATES
case GEOMOp::OpCheckSelfInters: // MENU MEASURE - CHECK SELF INTERSECTIONS
+ case GEOMOp::OpFastCheckInters: // MENU MEASURE - FAST CHECK INTERSECTIONS
case GEOMOp::OpManageDimensions: // MENU MEASURE - MANAGE DIMENSIONS
+ case GEOMOp::OpAnnotation: // MENU MEASURE - ANNOTATION
+ case GEOMOp::OpEditAnnotation: // POPUP MENU - EDIT ANNOTATION
+ case GEOMOp::OpDeleteAnnotation: // POPUP MENU - DELETE ANNOTATION
+#ifndef DISABLE_PLOT2DVIEWER
+ case GEOMOp::OpShapeStatistics: // MENU MEASURE - SHAPE STATISTICS
+#endif
case GEOMOp::OpShowAllDimensions: // POPUP MENU - SHOW ALL DIMENSIONS
case GEOMOp::OpHideAllDimensions: // POPUP MENU - HIDE ALL DIMENSIONS
+ case GEOMOp::OpShowAllAnnotations: // POPUP MENU - SHOW ALL ANNOTATIONS
+ case GEOMOp::OpHideAllAnnotations: // POPUP MENU - HIDE ALL ANNOTATIONS
libName = "MeasureGUI";
break;
case GEOMOp::OpGroupCreate: // MENU GROUP - CREATE
case GEOMOp::OpExplodeBlock: // MENU BLOCKS - EXPLODE ON BLOCKS
libName = "BlocksGUI";
break;
- case GEOMOp::OpExportXAO: // MENU NEW ENTITY - IMPORTEXPORT - EXPORTXAO
- case GEOMOp::OpImportXAO: // MENU NEW ENTITY - IMPORTEXPORT - IMPORTXAO
- libName = "ImportExportGUI";
- break;
//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
GEOMPluginGUI* library = 0;
if ( !libName.isEmpty() ) {
-#ifndef WIN32
- libName = QString( "lib" ) + libName + ".so";
-#else
+#if defined(WIN32)
libName = libName + ".dll";
+#elif defined(__APPLE__)
+ libName = QString( "lib" ) + libName + ".dylib";
+#else
+ libName = QString( "lib" ) + libName + ".so";
#endif
library = getPluginLibrary( libName );
}
GEOMGUI* library = 0;
if ( !libName.isEmpty() ) {
-#ifndef WIN32
- libName = QString( "lib" ) + libName + ".so";
-#else
+#if defined(WIN32)
libName = libName + ".dll";
+#elif defined(__APPLE__)
+ libName = QString( "lib" ) + libName + ".dylib";
+#else
+ libName = QString( "lib" ) + libName + ".so";
#endif
library = getLibrary( libName );
}
GetGeomGen()->PublishInStudy( aDSStudy, SALOMEDS::SObject::_nil(), anOX, "OX" );
GetGeomGen()->PublishInStudy( aDSStudy, SALOMEDS::SObject::_nil(), anOY, "OY" );
GetGeomGen()->PublishInStudy( aDSStudy, SALOMEDS::SObject::_nil(), anOZ, "OZ" );
+ anOrigin->UnRegister();
+ anOX->UnRegister();
+ anOY->UnRegister();
+ anOZ->UnRegister();
+ aBasicOperations->UnRegister();
getApp()->updateObjectBrowser( true );
}
// ----- create actions --------------
- createGeomAction( GEOMOp::OpImport, "IMPORT", "", Qt::ControlModifier + Qt::Key_I );
- createGeomAction( GEOMOp::OpExport, "EXPORT", "", Qt::ControlModifier + Qt::Key_E );
-
createGeomAction( GEOMOp::OpDelete, "DELETE", "", Qt::Key_Delete );
createGeomAction( GEOMOp::OpPoint, "POINT" );
createGeomAction( GEOMOp::OpPlane, "PLANE" );
createGeomAction( GEOMOp::OpLCS, "LOCAL_CS" );
createGeomAction( GEOMOp::OpOriginAndVectors, "ORIGIN_AND_VECTORS" );
+ createGeomAction( GEOMOp::OpSurfaceFromFace, "SURFACE_FROM_FACE" );
createGeomAction( GEOMOp::OpBox, "BOX" );
createGeomAction( GEOMOp::OpCylinder, "CYLINDER" );
createGeomAction( GEOMOp::OpFilling, "FILLING" );
createGeomAction( GEOMOp::OpPipe, "PIPE" );
createGeomAction( GEOMOp::OpPipePath, "PIPE_PATH" );
+ createGeomAction( GEOMOp::OpThickness, "THICKNESS" );
createGeomAction( GEOMOp::OpGroupCreate, "GROUP_CREATE" );
createGeomAction( GEOMOp::OpGroupEdit, "GROUP_EDIT" );
createGeomAction( GEOMOp::Op2dSketcher, "SKETCH" );
createGeomAction( GEOMOp::Op3dSketcher, "3DSKETCH" );
- createGeomAction( GEOMOp::OpIsoline, "ISOLINE" );
createGeomAction( GEOMOp::OpExplode, "EXPLODE" );
#ifdef WITH_OPENCV
createGeomAction( GEOMOp::OpFeatureDetect,"FEATURE_DETECTION" );
#endif
createGeomAction( GEOMOp::OpPictureImport,"PICTURE_IMPORT" );
+ createGeomAction( GEOMOp::Op2dPolylineEditor, "CURVE_CREATOR" );
createGeomAction( GEOMOp::OpEdge, "EDGE" );
createGeomAction( GEOMOp::OpWire, "WIRE" );
createGeomAction( GEOMOp::OpScale, "SCALE" );
createGeomAction( GEOMOp::OpOffset, "OFFSET" );
createGeomAction( GEOMOp::OpProjection, "PROJECTION" );
+ createGeomAction( GEOMOp::OpProjOnCyl, "PROJ_ON_CYL" );
createGeomAction( GEOMOp::OpMultiTranslate, "MUL_TRANSLATION" );
createGeomAction( GEOMOp::OpMultiRotate, "MUL_ROTATION" );
+ createGeomAction( GEOMOp::OpExtension, "EXTENSION" );
createGeomAction( GEOMOp::OpPartition, "PARTITION" );
createGeomAction( GEOMOp::OpArchimede, "ARCHIMEDE" );
createGeomAction( GEOMOp::OpFillet3d, "FILLET" );
createGeomAction( GEOMOp::OpChamfer, "CHAMFER" );
- //createGeomAction( GEOMOp::OpClipping, "CLIPPING" );
createGeomAction( GEOMOp::OpShapesOnShape, "GET_SHAPES_ON_SHAPE" );
createGeomAction( GEOMOp::OpSharedShapes, "GET_SHARED_SHAPES" );
+ createGeomAction( GEOMOp::OpTransferData, "TRANSFER_DATA" );
+ createGeomAction( GEOMOp::OpExtraction, "EXTRACTION" );
createGeomAction( GEOMOp::OpExtrudedCut, "EXTRUDED_CUT" );
createGeomAction( GEOMOp::OpExtrudedBoss, "EXTRUDED_BOSS" );
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- createGeomAction( GEOMOp::OpCurveCreator, "CURVE_CREATOR" );
-#endif
createGeomAction( GEOMOp::OpFillet1d, "FILLET_1D" );
createGeomAction( GEOMOp::OpFillet2d, "FILLET_2D" );
createGeomAction( GEOMOp::OpRemoveExtraEdges, "REMOVE_EXTRA_EDGES" );
createGeomAction( GEOMOp::OpFuseEdges, "FUSE_EDGES" );
createGeomAction( GEOMOp::OpUnionFaces, "UNION_FACES" );
+ createGeomAction( GEOMOp::OpInspectObj, "INSPECT_OBJECT" );
createGeomAction( GEOMOp::OpPointCoordinates, "POINT_COORDS" );
createGeomAction( GEOMOp::OpProperties, "BASIC_PROPS" );
createGeomAction( GEOMOp::OpMinDistance, "MIN_DIST" );
createGeomAction( GEOMOp::OpAngle, "MEASURE_ANGLE" );
createGeomAction( GEOMOp::OpManageDimensions, "MANAGE_DIMENSIONS" );
+ createGeomAction( GEOMOp::OpAnnotation, "ANNOTATION" );
+ createGeomAction( GEOMOp::OpEditAnnotation, "EDIT_ANNOTATION" );
+ createGeomAction( GEOMOp::OpDeleteAnnotation, "DELETE_ANNOTATION" );
createGeomAction( GEOMOp::OpTolerance, "TOLERANCE" );
createGeomAction( GEOMOp::OpWhatIs, "WHAT_IS" );
createGeomAction( GEOMOp::OpCheckCompound, "CHECK_COMPOUND" );
createGeomAction( GEOMOp::OpGetNonBlocks, "GET_NON_BLOCKS" );
createGeomAction( GEOMOp::OpCheckSelfInters, "CHECK_SELF_INTERSECTIONS" );
+ createGeomAction( GEOMOp::OpFastCheckInters, "FAST_CHECK_INTERSECTIONS" );
+#ifndef DISABLE_PLOT2DVIEWER
+ createGeomAction( GEOMOp::OpShapeStatistics, "SHAPE_STATISTICS" );
+#endif
+#ifndef DISABLE_PYCONSOLE
#ifdef _DEBUG_ // PAL16821
createGeomAction( GEOMOp::OpCheckGeom, "CHECK_GEOMETRY" );
+#endif
#endif
createGeomAction( GEOMOp::OpMaterialsLibrary, "MATERIALS_LIBRARY" );
createGeomAction( GEOMOp::OpHideAll, "ERASE_ALL" );
createGeomAction( GEOMOp::OpShow, "DISPLAY" );
createGeomAction( GEOMOp::OpSwitchVectors, "VECTOR_MODE");
+ createGeomAction( GEOMOp::OpSwitchVertices, "VERTICES_MODE");
+ createGeomAction( GEOMOp::OpSwitchName, "NAME_MODE");
createGeomAction( GEOMOp::OpSelectVertex, "VERTEX_SEL_ONLY" ,"", 0, true );
createGeomAction( GEOMOp::OpSelectEdge, "EDGE_SEL_ONLY", "", 0, true );
createGeomAction( GEOMOp::OpSelectWire, "WIRE_SEL_ONLY", "", 0, true );
createGeomAction( GEOMOp::OpEdgeWidth, "EDGE_WIDTH");
createGeomAction( GEOMOp::OpIsosWidth, "ISOS_WIDTH");
createGeomAction( GEOMOp::OpVectors, "POP_VECTORS", "", 0, true );
+ createGeomAction( GEOMOp::OpVertices, "POP_VERTICES", "", 0, true );
+ createGeomAction( GEOMOp::OpShowName, "POP_SHOW_NAME", "", 0, true );
createGeomAction( GEOMOp::OpDeflection, "POP_DEFLECTION" );
createGeomAction( GEOMOp::OpColor, "POP_COLOR" );
createGeomAction( GEOMOp::OpSetTexture, "POP_SETTEXTURE" );
createGeomAction( GEOMOp::OpPredefMaterCustom, "POP_PREDEF_MATER_CUSTOM" );
createGeomAction( GEOMOp::OpCreateFolder, "POP_CREATE_FOLDER" );
createGeomAction( GEOMOp::OpSortChildren, "POP_SORT_CHILD_ITEMS" );
+#ifndef DISABLE_GRAPHICSVIEW
createGeomAction( GEOMOp::OpShowDependencyTree, "POP_SHOW_DEPENDENCY_TREE" );
- createGeomAction( GEOMOp::OpShowAllDimensions, "POP_SHOW_ALL_DIMENSIONS" );
- createGeomAction( GEOMOp::OpHideAllDimensions, "POP_HIDE_ALL_DIMENSIONS" );
+#endif
+ createGeomAction( GEOMOp::OpReduceStudy, "POP_REDUCE_STUDY" );
+ createGeomAction( GEOMOp::OpShowAllDimensions, "POP_SHOW_ALL_DIMENSIONS" );
+ createGeomAction( GEOMOp::OpHideAllDimensions, "POP_HIDE_ALL_DIMENSIONS" );
+ createGeomAction( GEOMOp::OpShowAllAnnotations, "POP_SHOW_ALL_ANNOTATIONS" );
+ createGeomAction( GEOMOp::OpHideAllAnnotations, "POP_HIDE_ALL_ANNOTATIONS" );
// Create actions for increase/decrease transparency shortcuts
createGeomAction( GEOMOp::OpIncrTransparency, "", "", 0, false,
createGeomAction( GEOMOp::OpDecrNbIsos, "", "", 0, false,
"Geometry:Decrease number of isolines");
- // Import/Export XAO
- createGeomAction( GEOMOp::OpExportXAO, "EXPORTXAO" );
- createGeomAction( GEOMOp::OpImportXAO, "IMPORTXAO" );
-
//createGeomAction( GEOMOp::OpPipeTShape, "PIPETSHAPE" );
//createGeomAction( GEOMOp::OpDividedDisk, "DIVIDEDDISK" );
//createGeomAction( GEOMOp::OpDividedCylinder, "DIVIDEDCYLINDER" );
// ---- create menus --------------------------
- int fileId = createMenu( tr( "MEN_FILE" ), -1, -1 );
- createMenu( separator(), fileId, 10 );
- createMenu( GEOMOp::OpImport, fileId, 10 );
- createMenu( GEOMOp::OpExport, fileId, 10 );
- int impexpId = createMenu( tr( "MEN_IMPORTEXPORT" ), fileId, -1, 10 );
- createMenu( GEOMOp::OpExportXAO, impexpId, -1 );
- createMenu( GEOMOp::OpImportXAO, impexpId, -1 );
- createMenu( separator(), fileId, -1 );
+ /*int fileId =*/ createMenu( tr( "MEN_FILE" ), -1, -1 );
int editId = createMenu( tr( "MEN_EDIT" ), -1, -1 );
createMenu( GEOMOp::OpDelete, editId, -1 );
int newEntId = createMenu( tr( "MEN_NEW_ENTITY" ), -1, -1, 10 );
int basicId = createMenu( tr( "MEN_BASIC" ), newEntId, -1 );
- createMenu( GEOMOp::OpPoint, basicId, -1 );
- createMenu( GEOMOp::OpLine, basicId, -1 );
- createMenu( GEOMOp::OpCircle, basicId, -1 );
- 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( GEOMOp::OpIsoline, basicId, -1 );
- createMenu( separator(), basicId, -1 );
- createMenu( GEOMOp::OpVector, basicId, -1 );
- createMenu( GEOMOp::OpPlane, basicId, -1 );
- createMenu( GEOMOp::OpLCS, basicId, -1 );
+ createMenu( GEOMOp::OpPoint, basicId, -1 );
+ createMenu( GEOMOp::OpLine, basicId, -1 );
+ createMenu( GEOMOp::OpCircle, basicId, -1 );
+ createMenu( GEOMOp::OpEllipse, basicId, -1 );
+ createMenu( GEOMOp::OpArc, basicId, -1 );
+ createMenu( GEOMOp::OpCurve, basicId, -1 );
+ createMenu( GEOMOp::Op2dSketcher, basicId, -1 );
+ createMenu( GEOMOp::Op2dPolylineEditor, basicId, -1 );
+ createMenu( GEOMOp::Op3dSketcher, basicId, -1 );
+ createMenu( GEOMOp::OpIsoline, basicId, -1 );
+ createMenu( GEOMOp::OpSurfaceFromFace, 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::OpRevolution, genId, -1 );
createMenu( GEOMOp::OpFilling, genId, -1 );
createMenu( GEOMOp::OpPipe, genId, -1 );
-#if OCC_VERSION_LARGE > 0x06050300
createMenu( GEOMOp::OpPipePath, genId, -1 );
-#endif
+ createMenu( GEOMOp::OpThickness, genId, -1 );
//int advId = createMenu( tr( "MEN_ADVANCED" ), newEntId, -1 );
//createMenu( GEOMOp::OpSmoothingSurface, advId, -1 );
createMenu( GEOMOp::OpScale, transId, -1 );
createMenu( GEOMOp::OpOffset, transId, -1 );
createMenu( GEOMOp::OpProjection, transId, -1 );
+ createMenu( GEOMOp::OpExtension, transId, -1 );
+ createMenu( GEOMOp::OpProjOnCyl, transId, -1 );
createMenu( separator(), transId, -1 );
createMenu( GEOMOp::OpMultiTranslate, transId, -1 );
createMenu( GEOMOp::OpMultiRotate, transId, -1 );
createMenu( GEOMOp::OpArchimede, operId, -1 );
createMenu( GEOMOp::OpShapesOnShape, operId, -1 );
createMenu( GEOMOp::OpSharedShapes, operId, -1 );
+ createMenu( GEOMOp::OpTransferData, operId, -1 );
+ createMenu( GEOMOp::OpExtraction, operId, -1 );
createMenu( separator(), operId, -1 );
createMenu( GEOMOp::OpChamfer, operId, -1 );
createMenu( GEOMOp::OpExtrudedBoss, operId, -1 );
createMenu( GEOMOp::OpExtrudedCut, operId, -1 );
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- createMenu( separator(), operId, -1 );
- createMenu( GEOMOp::OpCurveCreator, operId, -1 );
-#endif
- //createMenu( GEOMOp::OpClipping, operId, -1 );
int repairId = createMenu( tr( "MEN_REPAIR" ), -1, -1, 10 );
createMenu( GEOMOp::OpShapeProcess, repairId, -1 );
createMenu( GEOMOp::OpAngle, dimId, -1 );
createMenu( GEOMOp::OpManageDimensions, dimId, -1 );
+ createMenu( GEOMOp::OpAnnotation, measurId, -1 );
+
createMenu( separator(), measurId, -1 );
createMenu( GEOMOp::OpTolerance, measurId, -1 );
createMenu( separator(), measurId, -1 );
createMenu( GEOMOp::OpCheckCompound, measurId, -1 );
createMenu( GEOMOp::OpGetNonBlocks, measurId, -1 );
createMenu( GEOMOp::OpCheckSelfInters, measurId, -1 );
+ createMenu( GEOMOp::OpFastCheckInters, measurId, -1 );
+ createMenu( GEOMOp::OpInspectObj, measurId, -1 );
+#ifndef DISABLE_PLOT2DVIEWER
+ createMenu( GEOMOp::OpShapeStatistics, measurId, -1 );
+#endif
int toolsId = createMenu( tr( "MEN_TOOLS" ), -1, -1, 50 );
+#ifndef DISABLE_PYCONSOLE
#if defined(_DEBUG_) || defined(_DEBUG) // PAL16821
createMenu( separator(), toolsId, -1 );
createMenu( GEOMOp::OpCheckGeom, toolsId, -1 );
+#endif
#endif
createMenu( separator(), toolsId, -1 );
createMenu( GEOMOp::OpDMTexture, dispmodeId, -1 );
createMenu( separator(), dispmodeId, -1 );
createMenu( GEOMOp::OpSwitchVectors, dispmodeId, -1 );
+ createMenu( GEOMOp::OpSwitchVertices, dispmodeId, -1 );
+ createMenu( GEOMOp::OpSwitchName, dispmodeId, -1 );
createMenu( separator(), viewId, -1 );
createMenu( GEOMOp::OpShowAll, viewId, -1 );
// ---- 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::Op2dSketcher, basicTbId ); //rnc
- createTool( GEOMOp::Op3dSketcher, basicTbId ); //rnc
- createTool( GEOMOp::OpIsoline, basicTbId );
- createTool( GEOMOp::OpPlane, basicTbId );
- createTool( GEOMOp::OpLCS, basicTbId );
+ int basicTbId = createTool( tr( "TOOL_BASIC" ), QString( "GEOMBasic" ) );
+ 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::Op2dPolylineEditor, basicTbId );
+ createTool( GEOMOp::Op3dSketcher, basicTbId ); //rnc
+ createTool( GEOMOp::OpIsoline, basicTbId );
+ createTool( GEOMOp::OpSurfaceFromFace, basicTbId );
+ createTool( GEOMOp::OpPlane, basicTbId );
+ createTool( GEOMOp::OpLCS, basicTbId );
createTool( GEOMOp::OpOriginAndVectors, basicTbId );
-// int sketchTbId = createTool( tr( "TOOL_SKETCH" ) );
+// int sketchTbId = createTool( tr( "TOOL_SKETCH" ), QString( "GEOMSketch" ) );
// createTool( GEOMOp::Op2dSketcher, sketchTbId );
// createTool( GEOMOp::Op3dSketcher, sketchTbId );
- int primTbId = createTool( tr( "TOOL_PRIMITIVES" ) );
+ int primTbId = createTool( tr( "TOOL_PRIMITIVES" ), QString( "GEOMPrimitives" ) );
createTool( GEOMOp::OpBox, primTbId );
createTool( GEOMOp::OpCylinder, primTbId );
createTool( GEOMOp::OpSphere, primTbId );
createTool( GEOMOp::OpDisk, primTbId );
//createTool( GEOMOp::OpPipeTShape, primTbId ); //rnc
- //int blocksTbId = createTool( tr( "TOOL_BLOCKS" ) );
+ //int blocksTbId = createTool( tr( "TOOL_BLOCKS" ), QString( "GEOMBlocks" ) );
//createTool( GEOMOp::OpDividedDisk, blocksTbId );
//createTool( GEOMOp::OpDividedCylinder, blocksTbId );
- int boolTbId = createTool( tr( "TOOL_BOOLEAN" ) );
+ int boolTbId = createTool( tr( "TOOL_BOOLEAN" ), QString( "GEOMBooleanOperations" ) );
createTool( GEOMOp::OpFuse, boolTbId );
createTool( GEOMOp::OpCommon, boolTbId );
createTool( GEOMOp::OpCut, boolTbId );
createTool( GEOMOp::OpSection, boolTbId );
- int genTbId = createTool( tr( "TOOL_GENERATION" ) );
+ int genTbId = createTool( tr( "TOOL_GENERATION" ), QString( "GEOMGeneration" ) );
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
+ createTool( GEOMOp::OpThickness, genTbId );
- int transTbId = createTool( tr( "TOOL_TRANSFORMATION" ) );
+ int transTbId = createTool( tr( "TOOL_TRANSFORMATION" ), QString( "GEOMTransformation" ) );
createTool( GEOMOp::OpTranslate, transTbId );
createTool( GEOMOp::OpRotate, transTbId );
createTool( GEOMOp::OpChangeLoc, transTbId );
createTool( GEOMOp::OpScale, transTbId );
createTool( GEOMOp::OpOffset, transTbId );
createTool( GEOMOp::OpProjection, transTbId );
+ createTool( GEOMOp::OpExtension, transTbId );
+ createTool( GEOMOp::OpProjOnCyl, transTbId );
createTool( separator(), transTbId );
createTool( GEOMOp::OpMultiTranslate, transTbId );
createTool( GEOMOp::OpMultiRotate, transTbId );
- int operTbId = createTool( tr( "TOOL_OPERATIONS" ) );
+ int operTbId = createTool( tr( "TOOL_OPERATIONS" ), QString( "GEOMOperations" ) );
createTool( GEOMOp::OpExplode, operTbId );
createTool( GEOMOp::OpPartition, operTbId );
createTool( GEOMOp::OpArchimede, operTbId );
createTool( GEOMOp::OpShapesOnShape, operTbId );
createTool( GEOMOp::OpSharedShapes, operTbId );
+ createTool( GEOMOp::OpTransferData, operTbId );
+ createTool( GEOMOp::OpExtraction, operTbId );
- int featTbId = createTool( tr( "TOOL_FEATURES" ) );
+ int featTbId = createTool( tr( "TOOL_FEATURES" ), QString( "GEOMModification" ) );
createTool( GEOMOp::OpFillet1d, featTbId );
createTool( GEOMOp::OpFillet2d, featTbId );
createTool( GEOMOp::OpFillet3d, featTbId );
createTool( GEOMOp::OpChamfer, featTbId );
createTool( GEOMOp::OpExtrudedBoss, featTbId );
createTool( GEOMOp::OpExtrudedCut, featTbId );
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- createTool( GEOMOp::OpCurveCreator, featTbId );
-#endif
- int buildTbId = createTool( tr( "TOOL_BUILD" ) );
+ int buildTbId = createTool( tr( "TOOL_BUILD" ), QString( "GEOMBuild" ) );
createTool( GEOMOp::OpEdge, buildTbId );
createTool( GEOMOp::OpWire, buildTbId );
createTool( GEOMOp::OpFace, buildTbId );
createTool( GEOMOp::OpSolid, buildTbId );
createTool( GEOMOp::OpCompound, buildTbId );
- int measureTbId = createTool( tr( "TOOL_MEASURES" ) );
+ int measureTbId = createTool( tr( "TOOL_MEASURES" ), QString( "GEOMMeasures" ) );
createTool( GEOMOp::OpPointCoordinates, measureTbId );
createTool( GEOMOp::OpProperties, measureTbId );
createTool( GEOMOp::OpCenterMass, measureTbId );
createTool( GEOMOp::OpBoundingBox, measureTbId );
createTool( GEOMOp::OpMinDistance, measureTbId );
createTool( GEOMOp::OpAngle, measureTbId );
+ createTool( GEOMOp::OpAnnotation, measureTbId );
createTool( GEOMOp::OpTolerance , measureTbId );
createTool( separator(), measureTbId );
createTool( GEOMOp::OpFreeBoundaries, measureTbId );
createTool( GEOMOp::OpCheckCompound, measureTbId );
createTool( GEOMOp::OpGetNonBlocks, measureTbId );
createTool( GEOMOp::OpCheckSelfInters, measureTbId );
+ createTool( GEOMOp::OpFastCheckInters, measureTbId );
- int picturesTbId = createTool( tr( "TOOL_PICTURES" ) );
+ int picturesTbId = createTool( tr( "TOOL_PICTURES" ), QString( "GEOMPictures" ) );
createTool( GEOMOp::OpPictureImport, picturesTbId );
#ifdef WITH_OPENCV
createTool( GEOMOp::OpFeatureDetect, picturesTbId );
#endif
- int impexpTbId = createTool( tr( "TOOL_IMPORTEXPORT" ) );
- createTool( GEOMOp::OpExportXAO, impexpTbId );
- createTool( GEOMOp::OpImportXAO, impexpTbId );
-
//int advancedTbId = createTool( tr( "TOOL_ADVANCED" ) );
//createTool( GEOMOp::OpSmoothingSurface, 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 @@//
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";
+ "(client='ObjectBrowser' or client='OCCViewer' or client='VTKViewer') and type='Shape' and selcount=1";
QtxPopupMgr* mgr = popupMgr();
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 isFolder=false and (selcount>0) and isOCC=true";
mgr->insert( action(GEOMOp::OpBringToFront ), -1, -1 ); // bring to front
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 + " and autoBringToFront = false", 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->insert( action( GEOMOp::OpVectors ), dispmodeId, -1 ); // vectors
mgr->setRule( action( GEOMOp::OpVectors ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->setRule( action( GEOMOp::OpVectors ), clientOCCorVTK + " and isVectorsMode", QtxPopupMgr::ToggleRule );
+ mgr->insert( action( GEOMOp::OpVertices ), dispmodeId, -1 ); // vertices
+ mgr->setRule( action( GEOMOp::OpVertices ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpVertices ), clientOCCorVTK + " and isVerticesMode", QtxPopupMgr::ToggleRule );
+ mgr->insert( action( GEOMOp::OpShowName ), dispmodeId, -1 ); // show name
+ mgr->setRule( action( GEOMOp::OpShowName ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpShowName ), clientOCCorVTK + " and isNameMode", QtxPopupMgr::ToggleRule );
mgr->insert( separator(), -1, -1 ); // -----------
mgr->insert( action( GEOMOp::OpColor ), -1, -1 ); // color
mgr->insert( action( GEOMOp::OpDeflection ), -1, -1 ); // deflection
mgr->setRule( action( GEOMOp::OpDeflection ), clientOCCorVTK_AndSomeVisible + " and selcount>0 and isVisible" + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpPointMarker ), -1, -1 ); // point marker
- //mgr->setRule( action( GEOMOp::OpPointMarker ), QString( "selcount>0 and $typeid in {%1}" ).arg(GEOM_POINT ), QtxPopupMgr::VisibleRule );
- mgr->setRule( action( GEOMOp::OpPointMarker ), QString( "selcount>0 and ( $typeid in {%1} or compoundOfVertices=true ) " ).arg(GEOM::VERTEX).arg(GEOM::COMPOUND), QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpPointMarker ), clientOCCorOB + " and $type in {'Shape' 'Group' 'Field' 'FieldStep'} and selcount>0 and isOCC=true", QtxPopupMgr::VisibleRule );
// material properties
mgr->insert( action( GEOMOp::OpMaterialProperties ), -1, -1 );
mgr->setRule( action( GEOMOp::OpNoAutoColor ), autoColorPrefix + " and isAutoColor=true", QtxPopupMgr::VisibleRule );
mgr->insert( separator(), -1, -1 ); // -----------
+ mgr->insert( action( GEOMOp::OpEditAnnotation ), -1, -1 ); // edit annotation
+ mgr->setRule( action( GEOMOp::OpEditAnnotation ), clientOCC + " and annotationsCount=1", QtxPopupMgr::VisibleRule );
+ mgr->insert( action( GEOMOp::OpDeleteAnnotation ), -1, -1 ); // delete annotation
+ mgr->setRule( action( GEOMOp::OpDeleteAnnotation ), clientOCC + " and annotationsCount>0", QtxPopupMgr::VisibleRule );
+ mgr->insert( separator(), -1, -1 ); // -----------
+
QString canDisplay = "($component={'GEOM'}) and (selcount>0) and ({true} in $canBeDisplayed) ",
onlyComponent = "((type='Component') and selcount=1)",
rule = canDisplay + "and ((($type in {%1}) and( %2 )) or " + onlyComponent + ")",
mgr->setRule( action( GEOMOp::OpShowAllDimensions ), aDimensionRule.arg( "hasHiddenDimensions" ), QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpHideAllDimensions ), -1, -1 ); // hide all dimensions
mgr->setRule( action( GEOMOp::OpHideAllDimensions ), aDimensionRule.arg( "hasVisibleDimensions" ), QtxPopupMgr::VisibleRule );
+ mgr->insert( action( GEOMOp::OpShowAllAnnotations ), -1, -1 ); // show all annotations
+ mgr->setRule( action( GEOMOp::OpShowAllAnnotations ), aDimensionRule.arg( "hasHiddenAnnotations" ), QtxPopupMgr::VisibleRule );
+ mgr->insert( action( GEOMOp::OpHideAllAnnotations ), -1, -1 ); // hide all annotations
+ mgr->setRule( action( GEOMOp::OpHideAllAnnotations ), aDimensionRule.arg( "hasVisibleAnnotations" ), QtxPopupMgr::VisibleRule );
mgr->insert( separator(), -1, -1 ); // -----------
mgr->insert( action( GEOMOp::OpUnpublishObject ), -1, -1 ); // Unpublish object
mgr->insert( action( GEOMOp::OpSortChildren ), -1, -1 ); // Sort child items
mgr->setRule( action( GEOMOp::OpSortChildren ), QString("client='ObjectBrowser' and $component={'GEOM'} and nbChildren>1"), QtxPopupMgr::VisibleRule );
+#ifndef DISABLE_GRAPHICSVIEW
mgr->insert( separator(), -1, -1 ); // -----------
mgr->insert( action( GEOMOp::OpShowDependencyTree ), -1, -1 ); // Show dependency tree
mgr->setRule( action( GEOMOp::OpShowDependencyTree ), clientOCCorVTKorOB + " and selcount>0 and ($component={'GEOM'}) and type='Shape'", QtxPopupMgr::VisibleRule );
+#endif
+
+ mgr->insert( separator(), -1, -1 ); // -----------
+ mgr->insert( action( GEOMOp::OpReduceStudy ), -1, -1 ); // Reduce Study
+ mgr->setRule( action( GEOMOp::OpReduceStudy ), clientOCCorVTKorOB + " and selcount>0 and ($component={'GEOM'}) and type='Shape'", QtxPopupMgr::VisibleRule );
mgr->hide( mgr->actionId( action( myEraseAll ) ) );
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
if (!resMgr) return;
- // Find names of a resource XML files ("GEOMActions.xml" and others);
- QString PluginsXml;
- char* cenv = getenv("GEOM_PluginsList");
- if (cenv)
- PluginsXml.sprintf("%s", cenv);
-
- QStringList PluginsXmlList = PluginsXml.split(":", QString::SkipEmptyParts);
- if (PluginsXmlList.count() == 0) return;
-
- // get full names of xml files from PluginsXmlList
- QStringList xmlFiles;
- xmlFiles.append(QDir::home().filePath("CustomGeomPlugins.xml")); // may be inexistent
- for (int i = 0; i < PluginsXmlList.count(); i++) {
- PluginsXml = PluginsXmlList[ i ];
-
- // Find full path to the resource XML file
- QString xmlFile = resMgr->path("resources", "GEOM", PluginsXml + ".xml");
- if ( xmlFile.isEmpty() ) // try PLUGIN resources
- xmlFile = resMgr->path("resources", PluginsXml, PluginsXml + ".xml");
- if ( !xmlFile.isEmpty() )
- xmlFiles.append( xmlFile );
- }
-
- // create "Advanced Operations" menu and corresponding toolbar
- //int advancedMenuId = createMenu(tr("MEN_ADVANCED"), -1, -1, 10);
- //int advancedTbarId = createTool(tr("TOOL_ADVANCED"));
- int id = GEOMOp::OpLastOperationID; // TODO?
+ SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
+ if (!appStudy) return;
- // loop on xmlFiles
- QString aNoAccessFiles;
- for (int i = 0; i < xmlFiles.count(); i++) {
- QString xmlFile = xmlFiles[ i ];
-
- QFile file (xmlFile);
- if (file.exists() && file.open(QIODevice::ReadOnly)) {
- file.close();
-
- GEOMGUI_XmlHandler* aXmlHandler = new GEOMGUI_XmlHandler();
- ASSERT(aXmlHandler);
-
- QXmlInputSource source (&file);
- QXmlSimpleReader reader;
- reader.setContentHandler(aXmlHandler);
- reader.setErrorHandler(aXmlHandler);
- bool ok = reader.parse(source);
- file.close();
-
- if (ok) {
- // bind action lib and label to its ID for activateOperation() method proper work
- myPluginLibs[aXmlHandler->myPluginData.myName] = aXmlHandler->myPluginData.myClientLib;
-
- QListIterator<GEOMGUI_ActionData> anActionsIter (aXmlHandler->myPluginData.myListOfActions);
- while (anActionsIter.hasNext()) {
- GEOMGUI_ActionData anActionData = anActionsIter.next();
-
- //QPixmap icon = resMgr->loadPixmap("GEOM", tr(anActionData.myIcon.toLatin1().constData()));
- QPixmap icon = resMgr->loadPixmap(aXmlHandler->myPluginData.myName,
- anActionData.myIcon.toLatin1().constData());
-
- // path to action in menu
- QStringList smenus = anActionData.myMenu.split( "/" );
- QString actionName = smenus.last();
- actionName = actionName.toUpper().prepend("MEN_");
- smenus.removeLast();
-
- // path to action in toolbar
- QStringList stools = anActionData.myTooltip.split( "/" );
- QString actionTool = stools.last();
- actionTool = actionTool.toUpper().prepend("TOP_");
- stools.removeLast();
-
- QString actionStat = anActionData.myStatusBar;
- actionStat = actionStat.toUpper().prepend("STB_");
-
- createAction(id, // ~ anActionData.myLabel
- tr(actionTool.toLatin1().constData()),
- icon,
- tr(actionName.toLatin1().constData()),
- tr(actionStat.toLatin1().constData()),
- 0 /*accel*/,
- application()->desktop(),
- false /*toggle*/,
- this, SLOT(OnGUIEvent()),
- QString() /*shortcutAction*/);
-
- int menuId = -1;
- foreach (QString subMenu, smenus) {
- subMenu = subMenu.toUpper().prepend("MEN_");
- menuId = createMenu(tr(subMenu.toLatin1().constData()), menuId, -1);
- }
- //createMenu(id, pluginMenuId, -1);
- createMenu(id, menuId, -1);
+ // Find names of a resource XML files ("AdvancedGEOM.xml" and others);
- QString subTool = stools[0];
- subTool = subTool.toUpper().prepend("TOOL_");
- int toolId = createTool(tr(subTool.toLatin1().constData()));
- //createTool(id, advancedTbarId);
- createTool(id, toolId);
+ GEOMUtils::PluginInfo plugins = GEOMUtils::ReadPluginInfo();
- // add action id to map
- PluginAction anAction (aXmlHandler->myPluginData.myClientLib, anActionData.myLabel);
- myPluginActions[id] = anAction;
+ int id = GEOMOp::OpLastOperationID; // TODO?
- id++;
- }
+ // loop on plugins
+ GEOMUtils::PluginInfo::const_iterator it;
+ for ( it = plugins.begin(); it != plugins.end(); ++it ) {
+ // bind action lib and label to its ID for activateOperation() method proper work
+ GEOMUtils::PluginData pdata = (*it);
+ myPluginLibs[pdata.name.c_str()] = pdata.clientLib.c_str();
+ std::list<GEOMUtils::ActionData> actions = (*it).actions;
+ std::list<GEOMUtils::ActionData>::const_iterator ait;
+ for ( ait = actions.begin(); ait != actions.end(); ++ait ) {
+ GEOMUtils::ActionData adata = (*ait);
+ // icon
+ QPixmap icon;
+ if ( !adata.icon.empty() )
+ icon = resMgr->loadPixmap( pdata.name.c_str(), adata.icon.c_str() );
+ // menu text (path)
+ QStringList smenus = QString( adata.menuText.c_str() ).split( "/" );
+ QString actionName = smenus.last();
+ actionName = actionName.toUpper().prepend( "MEN_" );
+ smenus.removeLast();
+
+ // path to action in toolbar
+ QStringList stools = QString( adata.toolTip.c_str() ).split( "/" );
+ QString actionTool = stools.last();
+ actionTool = actionTool.toUpper().prepend( "TOP_" );
+ stools.removeLast();
+
+ QString actionStat = adata.statusText.c_str();
+ actionStat = actionStat.toUpper().prepend( "STB_" );
+
+ createAction( id, // ~ adata.label
+ tr( actionTool.toLatin1().constData() ),
+ icon,
+ tr( actionName.toLatin1().constData() ),
+ tr( actionStat.toLatin1().constData() ),
+ QKeySequence( tr( adata.accel.c_str() ) ),
+ application()->desktop(),
+ false /*toggle*/,
+ this, SLOT( OnGUIEvent() ),
+ QString() /*shortcutAction*/ );
+
+ int menuId = -1;
+ foreach ( QString subMenu, smenus ) {
+ QStringList subMenuList = subMenu.split( ":" );
+ QString subMenuName = subMenuList[0].toUpper().prepend( "MEN_" );
+ int subMenuGroup = subMenuList.size() > 1 ? subMenuList[1].toInt() : -1;
+ menuId = createMenu( tr( subMenuName.toLatin1().constData() ), menuId, -1, subMenuGroup );
}
- else {
- SUIT_MessageBox::critical(application()->desktop(),
- tr("INF_PARSE_ERROR"),
- tr(aXmlHandler->errorProtocol().toLatin1().data()));
+ createMenu( id, menuId, -1 );
+
+ if ( !stools.isEmpty() ) {
+ QString subTool = stools[0];
+ subTool = subTool.toUpper().prepend( "TOOL_" );
+ int toolId = createTool( tr( subTool.toLatin1().constData() ) );
+ createTool(id, toolId);
}
- delete aXmlHandler;
- }
- else if ( i > 0 ) { // 1st is ~/CustomGeomPlugins.xml
- if (aNoAccessFiles.isEmpty())
- aNoAccessFiles = xmlFile;
- else
- aNoAccessFiles += ", " + xmlFile;
- }
- } // end loop on xmlFiles
- if (!aNoAccessFiles.isEmpty()) {
- QString aMess = QObject::tr("PLUGIN_FILE_CANT_OPEN") + " " + aNoAccessFiles + "\n";
- aMess += QObject::tr("PLUGIN_FILE_CHECK_VARIABLE");
- SUIT_MessageBox::warning(application()->desktop(), tr("GEOM_WRN_WARNING"), aMess);
+ // add action id to map
+ PluginAction anAction( pdata.clientLib.c_str(), adata.label.c_str() );
+ myPluginActions[id] = anAction;
+
+ id++;
+ }
}
}
// import Python module that manages GEOM plugins (need to be here because SalomePyQt API uses active module)
PyGILState_STATE gstate = PyGILState_Ensure();
- PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
+ PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
if ( !pluginsmanager ) {
PyErr_Print();
}
else {
- PyObjWrapper result =
+ 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());
+ tr("MEN_NEW_ENTITY").toUtf8().data(),
+ tr("GEOM_PLUGINS_OTHER").toUtf8().data());
if ( !result )
PyErr_Print();
+ Py_XDECREF(result);
}
PyGILState_Release(gstate);
// end of GEOM plugins loading
connect( application()->desktop(), SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
- this, SLOT( onWindowActivated( SUIT_ViewWindow* ) ) );
+ this, SLOT( onWindowActivated( SUIT_ViewWindow* ) ), Qt::UniqueConnection );
// Reset actions accelerator keys
- 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
GUIMap::Iterator it;
LightApp_SelectionMgr* sm = getApp()->selectionMgr();
- connect( sm, SIGNAL( currentSelectionChanged() ), this, SLOT( updateCreationInfo() ));
- connect( sm, SIGNAL( currentSelectionChanged() ), this, SLOT( onAutoBringToFront() ));
- connect( sm, SIGNAL( currentSelectionChanged() ), this, SLOT( updateFieldColorScale() ));
+ connect( sm, SIGNAL( currentSelectionChanged() ), this, SLOT( updateCreationInfo() ), Qt::UniqueConnection );
+ connect( sm, SIGNAL( currentSelectionChanged() ), this, SLOT( onAutoBringToFront() ), Qt::UniqueConnection );
+ connect( sm, SIGNAL( currentSelectionChanged() ), this, SLOT( updateFieldColorScale() ), Qt::UniqueConnection );
if ( !myCreationInfoWdg )
myCreationInfoWdg = new GEOMGUI_CreationInfoWdg( getApp() );
getApp()->insertDockWindow( myCreationInfoWdg->getWinID(), myCreationInfoWdg );
getApp()->placeDockWindow( myCreationInfoWdg->getWinID(), Qt::LeftDockWidgetArea );
+ if ( !myTextTreeWdg ) {
+ myTextTreeWdg = new GEOMGUI_TextTreeWdg( getApp() );
+ new GEOMGUI_TextTreeSelector( myTextTreeWdg, GetAnnotationMgr(), getApp()->selectionMgr() );
+ }
+
+ getApp()->insertDockWindow( myTextTreeWdg->getWinID(), myTextTreeWdg );
+ getApp()->placeDockWindow( myTextTreeWdg->getWinID(), Qt::LeftDockWidgetArea );
+
+ //NPAL 19674
+ SALOME_ListIO selected;
+ sm->selectedObjects( selected );
+ sm->clearSelected();
+
SUIT_ViewManager* vm;
ViewManagerList OCCViewManagers, VTKViewManagers;
application()->viewManagers( OCCViewer_Viewer::Type(), OCCViewManagers );
QListIterator<SUIT_ViewManager*> itOCC( OCCViewManagers );
while ( itOCC.hasNext() && (vm = itOCC.next()) )
- myOCCSelectors.append( new GEOMGUI_OCCSelector( ((OCCViewer_ViewManager*)vm)->getOCCViewer(), sm ) );
+ onViewManagerAdded(vm);
application()->viewManagers( SVTK_Viewer::Type(), VTKViewManagers );
QListIterator<SUIT_ViewManager*> itVTK( VTKViewManagers );
while ( itVTK.hasNext() && (vm = itVTK.next()) )
- myVTKSelectors.append( new LightApp_VTKSelector( dynamic_cast<SVTK_Viewer*>( vm->getViewModel() ), sm ) );
-
- //NPAL 19674
- SALOME_ListIO selected;
- sm->selectedObjects( selected );
- sm->clearSelected();
-
- // disable OCC selectors
- getApp()->selectionMgr()->setEnabled( false, OCCViewer_Viewer::Type() );
- QListIterator<GEOMGUI_OCCSelector*> itOCCSel( myOCCSelectors );
- while ( itOCCSel.hasNext() )
- if ( GEOMGUI_OCCSelector* sr = itOCCSel.next() )
- sr->setEnabled(true);
-
- // disable VTK selectors
- getApp()->selectionMgr()->setEnabled( false, SVTK_Viewer::Type() );
- QListIterator<LightApp_VTKSelector*> itVTKSel( myVTKSelectors );
- while ( itVTKSel.hasNext() )
- if ( LightApp_VTKSelector* sr = itVTKSel.next() )
- sr->setEnabled(true);
+ onViewManagerAdded(vm);
sm->setSelectedObjects( selected, true ); //NPAL 19674
QMenu* viewMenu = menuMgr()->findMenu( STD_Application::MenuViewId );
if ( viewMenu )
- connect( viewMenu, SIGNAL( aboutToShow() ), this, SLOT( onViewAboutToShow() ) );
+ connect( viewMenu, SIGNAL( aboutToShow() ), this, SLOT( onViewAboutToShow() ), Qt::UniqueConnection );
// 0020836 (Basic vectors and origin)
SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
}
}
+ Py_XDECREF(pluginsmanager);
return true;
}
LightApp_SelectionMgr* selMrg = getApp()->selectionMgr();
disconnect( selMrg, SIGNAL( currentSelectionChanged() ), this, SLOT( updateCreationInfo() ));
- disconnect( selMrg, SIGNAL( currentSelectionChanged() ), this, SLOT( updateFieldColorScale() ));
- getApp()->removeDockWindow( myCreationInfoWdg->getWinID() );
- myCreationInfoWdg = 0;
+ //disconnect( selMrg, SIGNAL( currentSelectionChanged() ), this, SLOT( updateFieldColorScale() ));
+ if ( myCreationInfoWdg ) {
+ getApp()->removeDockWindow( myCreationInfoWdg->getWinID() );
+ myCreationInfoWdg = 0;
+ }
+ if ( myTextTreeWdg ) {
+ getApp()->removeDockWindow( myTextTreeWdg->getWinID() );
+ disconnect( application(), 0, myTextTreeWdg, 0 );
+ myTextTreeWdg = 0;
+ }
EmitSignalCloseAllDialogs();
it.value()->deactivate();
// Unset actions accelerator keys
- 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
qDeleteAll(myOCCSelectors);
if ( !win )
return;
- const bool ViewOCC = ( win->getViewManager()->getType() == OCCViewer_Viewer::Type() );
- //const bool ViewVTK = ( win->getViewManager()->getType() == SVTK_Viewer::Type() );
+ const bool ViewOCC = ( win->getViewManager() ? win->getViewManager()->getType() == OCCViewer_Viewer::Type() : false );
+ //const bool ViewVTK = ( win->getViewManager() ? win->getViewManager()->getType() == SVTK_Viewer::Type() : false );
// disable non-OCC viewframe menu commands
// action( GEOMOp::Op2dSketcher )->setEnabled( ViewOCC ); // SKETCHER
{
mappa.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
mappa.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
+#ifndef DISABLE_PYCONSOLE
mappa.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
+#endif
if ( myCreationInfoWdg )
mappa.insert( myCreationInfoWdg->getWinID(), Qt::LeftDockWidgetArea );
+ if ( myTextTreeWdg )
+ mappa.insert( myTextTreeWdg->getWinID(), Qt::LeftDockWidgetArea );
}
void GeometryGUI::viewManagers( QStringList& lst ) const
break;
}
}
+ SOCC_Viewer* aSOCCView = dynamic_cast<SOCC_Viewer*>(viewer);
+ if ( aSOCCView ) {
+ GetAnnotationMgr()->RemoveView( aSOCCView );
+ }
}
//================================================================================
// pass creation info of geomObj to myCreationInfoWdg
if ( myCreationInfoWdg ) {
- QPixmap icon;
- QString operationName;
- myCreationInfoWdg->setOperation( icon, operationName );
+ GEOM::CreationInformationSeq_var info;
try {
OCC_CATCH_SIGNALS;
- GEOM::CreationInformation_var info = geomObj->GetCreationInformation();
- if ( &info.in() ) {
- SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
- QString name = info->operationName.in();
- if ( !name.isEmpty() ) {
- icon = resMgr->loadPixmap( "GEOM", tr( ("ICO_"+name).toLatin1().constData() ), false );
- operationName = tr( ("MEN_"+name).toLatin1().constData() );
- if ( operationName.startsWith( "MEN_" ))
- operationName = name; // no translation
- myCreationInfoWdg->setOperation( icon, operationName );
-
- for ( size_t i = 0; i < info->params.length(); ++i )
- myCreationInfoWdg->addParam( info->params[i].name.in(),
- info->params[i].value.in() );
- }
- }
+ info = geomObj->GetCreationInformation();
}
catch (...) {
}
+ myCreationInfoWdg->setInfo( info );
}
}
void GeometryGUI::onAutoBringToFront()
{
- bool isAutoBringToFront = SUIT_Session::session()->resourceMgr()->booleanValue( "Geometry", "auto_bring_to_front" );
+ bool isAutoBringToFront = SUIT_Session::session()->resourceMgr()->booleanValue( "Geometry", "auto_bring_to_front", "false" );
if( !isAutoBringToFront )
return;
{
if( SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( getApp()->activeStudy() ) )
{
- GEOM_Displayer aDisplayer( aStudy );
- aDisplayer.UpdateColorScale();
+ GEOM_Displayer( aStudy ).UpdateColorScale();
}
}
return "";
}
-#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;
-#endif
if (theStudy) {
TextureMap aTextureMap = myTextureMap[ theStudy->studyDS()->StudyId() ];
theWidth = aWidth;
theHeight = aHeight;
-#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++)
+ for ( CORBA::ULong i = 0; i < aStream->length(); i++)
aTexture->SetValue( i+1, (Standard_Byte)aStream[i] );
aTextureMap[ theId ] = aTexture;
}
void GeometryGUI::createPreferences()
{
+ SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
+
int tabId = addPreference( tr( "PREF_TAB_SETTINGS" ) );
int genGroup = addPreference( tr( "PREF_GROUP_GENERAL" ), tabId );
addPreference( tr( "PREF_ISOS_COLOR" ), genGroup,
LightApp_Preferences::Color, "Geometry", "isos_color" );
+ addPreference( tr( "PREF_LABEL_COLOR" ), genGroup,
+ LightApp_Preferences::Color, "Geometry", "label_color" );
+
+ addPreference( "", genGroup, LightApp_Preferences::Space );
+
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 transparency = addPreference( tr( "PREF_TRANSPARENCY" ), genGroup,
+ LightApp_Preferences::IntSpin, "Geometry", "transparency" );
int defl = addPreference( tr( "PREF_DEFLECTION" ), genGroup,
LightApp_Preferences::DblSpin, "Geometry", "deflection_coeff" );
setPreferenceProperty( wd[i], "max", 5 );
}
+ int step = addPreference( tr( "PREF_STEP_VALUE" ), genGroup,
+ LightApp_Preferences::IntSpin, "Geometry", "SettingsGeomStep" );
+
addPreference( tr( "PREF_AUTO_BRING_TO_FRONT" ), genGroup,
LightApp_Preferences::Bool, "Geometry", "auto_bring_to_front" );
+ // --------------------------------------------------------------------------
+ // Dimensions (Measurements) preferences
+ // --------------------------------------------------------------------------
+
int aDimGroupId = addPreference( tr( "PREF_DIMENSIONS" ), tabId );
setPreferenceProperty( aDimGroupId, "columns", 2 );
setPreferenceProperty( aDimLineWidthId, "min", 1 );
setPreferenceProperty( aDimLineWidthId, "max", 5 );
- int aDimFontHeightId = addPreference( tr( "PREF_DIMENSIONS_FONT_HEIGHT" ), aDimGroupId,
- LightApp_Preferences::DblSpin, "Geometry", "dimensions_font_height" );
-
- setPreferenceProperty( aDimFontHeightId, "min", 1e-9 );
- setPreferenceProperty( aDimFontHeightId, "max", 1e+9 );
- setPreferenceProperty( aDimFontHeightId, "precision", 9 );
+ int aDimFontId = addPreference( tr( "PREF_DIMENSIONS_FONT" ), aDimGroupId, LightApp_Preferences::Font, "Geometry", "dimensions_font" );
+
+ int f = QtxFontEdit::Family | QtxFontEdit::Size;
+ setPreferenceProperty( aDimFontId, "features", f );
+ setPreferenceProperty( aDimFontId, "mode", QtxFontEdit::Custom );
+
+ Handle(Font_FontMgr) fmgr = Font_FontMgr::GetInstance();
+ QString aFontFile = "";
+ resMgr->value("resources", "GEOM", aFontFile);
+ aFontFile = aFontFile + QDir::separator() + "Y14.5M-2009.ttf";
+ // add enginier font into combobox
+ /*int fontID =*/ QFontDatabase::addApplicationFont( aFontFile );
+ Handle(Font_SystemFont) sf = new Font_SystemFont(
+ new TCollection_HAsciiString("Y14.5M-2009"),
+ Font_FA_Regular,
+ new TCollection_HAsciiString(aFontFile.toLatin1().data()) );
+ // register font in OCC font manager
+ fmgr->RegisterFont( sf, Standard_False );
+
+ // get list of supported fonts by OCC
+ QStringList anOCCFonts;
+ TColStd_SequenceOfHAsciiString theFontsNames;
+ fmgr->GetAvailableFontsNames( theFontsNames );
+ for(Standard_Integer i=1; i<=theFontsNames.Length(); i++) {
+ Handle(TCollection_HAsciiString) str = theFontsNames(i);
+ anOCCFonts << str->ToCString();
+ }
+ anOCCFonts.removeDuplicates();
+ // set the supported fonts into combobox to use its only
+ setPreferenceProperty( aDimFontId, "fonts", anOCCFonts );
int aDimArrLengthId = addPreference( tr( "PREF_DIMENSIONS_ARROW_LENGTH" ), aDimGroupId,
LightApp_Preferences::DblSpin, "Geometry", "dimensions_arrow_length" );
int anAngUnitsId = addPreference( tr( "PREF_DIMENSIONS_ANGLE_UNITS" ), aDimGroupId,
LightApp_Preferences::Selector, "Geometry", "dimensions_angle_units" );
- addPreference( tr( "PREF_DIMENSIONS_SHOW_UNITS" ), aDimGroupId,
- LightApp_Preferences::Bool, "Geometry", "dimensions_show_units" );
-
QStringList aListOfLengthUnits;
aListOfLengthUnits << "m";
aListOfLengthUnits << "cm";
setPreferenceProperty( aLengthUnitsId, "strings", aListOfLengthUnits );
setPreferenceProperty( anAngUnitsId, "strings", aListOfAngUnits );
+ addPreference( tr( "PREF_DIMENSIONS_SHOW_UNITS" ), aDimGroupId,
+ LightApp_Preferences::Bool, "Geometry", "dimensions_show_units" );
+
int aDimDefFlyout = addPreference( tr( "PREF_DIMENSIONS_DEFAULT_FLYOUT" ), aDimGroupId,
LightApp_Preferences::DblSpin, "Geometry", "dimensions_default_flyout" );
setPreferenceProperty( aDimDefFlyout, "max", 1e+9 );
setPreferenceProperty( aDimDefFlyout, "precision", 9 );
+ addPreference( tr( "PREF_DIMENSIONS_USE_TEXT3D" ), aDimGroupId,
+ LightApp_Preferences::Bool, "Geometry", "dimensions_use_text3d" );
+
+ // --------------------------------------------------------------------------
+ // Shape annotation preferences
+ // --------------------------------------------------------------------------
+
+ const int aShapeAnnGroupId = addPreference( tr( "PREF_SHAPE_ANNOTATIONS" ), tabId );
+ setPreferenceProperty( aShapeAnnGroupId, "columns", 2 );
+
+ addPreference( tr( "PREF_SHAPE_ANNOTATIONS_FONT_COLOR" ), aShapeAnnGroupId, LightApp_Preferences::Color, "Geometry", "shape_annotation_font_color" );
+ addPreference( tr( "PREF_SHAPE_ANNOTATIONS_LINE_COLOR" ), aShapeAnnGroupId, LightApp_Preferences::Color, "Geometry", "shape_annotation_line_color" );
+ const int aShapeAnnFont =
+ addPreference( tr( "PREF_SHAPE_ANNOTATIONS_FONT" ), aShapeAnnGroupId, LightApp_Preferences::Font, "Geometry", "shape_annotation_font" );
+
+ int aShapeAnnFontFeatures = QtxFontEdit::Family | QtxFontEdit::Size | QtxFontEdit::Bold | QtxFontEdit::Italic;
+ setPreferenceProperty( aShapeAnnFont, "features", aShapeAnnFontFeatures );
+ setPreferenceProperty( aShapeAnnFont, "mode", QtxFontEdit::Custom );
+ setPreferenceProperty( aShapeAnnFont, "fonts", anOCCFonts );
+
+ const int aShapeAnnLineWidth =
+ addPreference( tr( "PREF_SHAPE_ANNOTATIONS_LINE_WIDTH" ), aShapeAnnGroupId, LightApp_Preferences::IntSpin, "Geometry", "shape_annotation_line_width" );
+
+ setPreferenceProperty( aShapeAnnLineWidth, "min", 1 );
+ setPreferenceProperty( aShapeAnnLineWidth, "max", 5 );
+
+ addPreference( tr( "PREF_SHAPE_ANNOTATIONS_AUTOHIDE" ), aShapeAnnGroupId, LightApp_Preferences::Bool, "Geometry", "shape_annotation_autohide" );
+
+ const int aShapeAnnLineStyle =
+ addPreference( tr( "PREF_SHAPE_ANNOTATIONS_LINE_STYLE" ), aShapeAnnGroupId, LightApp_Preferences::Selector, "Geometry", "shape_annotation_line_style" );
+
+ QStringList aLineStyleList;
+ aLineStyleList.append( tr("PREF_SHAPE_ANNOTATIONS_LINESTYLE_SOLID") );
+ aLineStyleList.append( tr("PREF_SHAPE_ANNOTATIONS_LINESTYLE_DASH") );
+ aLineStyleList.append( tr("PREF_SHAPE_ANNOTATIONS_LINESTYLE_DOT") );
+ aLineStyleList.append( tr("PREF_SHAPE_ANNOTATIONS_LINESTYLE_DOTDASH") );
+
+ QList<QVariant> aLineStyleIds;
+ aLineStyleIds.append(0);
+ aLineStyleIds.append(1);
+ aLineStyleIds.append(2);
+ aLineStyleIds.append(3);
+
+ setPreferenceProperty( aShapeAnnLineStyle, "strings", aLineStyleList );
+ setPreferenceProperty( aShapeAnnLineStyle, "indexes", aLineStyleIds );
+
+ // --------------------------------------------------------------------------
+ // Isoline drawing preferences
+ // --------------------------------------------------------------------------
+
int isoGroup = addPreference( tr( "PREF_ISOS" ), tabId );
setPreferenceProperty( isoGroup, "columns", 2 );
int isoU = addPreference( tr( "PREF_ISOS_U" ), isoGroup,
setPreferenceProperty( step, "max", 10000 );
setPreferenceProperty( step, "precision", 3 );
+ // Set property for trandparency value for spinboxes
+ setPreferenceProperty( transparency, "min", 0 );
+ setPreferenceProperty( transparency, "max", 100 );
+
// Set property for deflection value for spinboxes
setPreferenceProperty( defl, "min", GEOM::minDeflection() );
setPreferenceProperty( defl, "max", 1.0 );
QList<QVariant> aMarkerTypeIndicesList;
QList<QVariant> aMarkerTypeIconsList;
- SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
for ( int i = GEOM::MT_POINT; i < GEOM::MT_USER; i++ ) {
QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
QPixmap pixmap = resMgr->loadPixmap( "GEOM", tr( qPrintable( icoFile ) ) );
addPreference( tr( "GEOM_PREVIEW" ), operationsGroup,
LightApp_Preferences::Bool, "Geometry", "geom_preview" );
+ addPreference( tr( "PREF_HIDE_INPUT_OBJECT" ), operationsGroup,
+ LightApp_Preferences::Bool, "Geometry", "hide_input_object" );
+
int DependencyViewId = addPreference( tr( "PREF_TAB_DEPENDENCY_VIEW" ) );
- int hierarchy_type = addPreference( tr( "PREF_HIERARCHY_TYPE" ), DependencyViewId,
+ int treeGeneralGroup = addPreference( tr( "PREF_GROUP_GENERAL" ), DependencyViewId );
+
+ int hierarchy_type = addPreference( tr( "PREF_HIERARCHY_TYPE" ), treeGeneralGroup,
LightApp_Preferences::Selector, "Geometry", "dependency_tree_hierarchy_type" );
QStringList aHierarchyTypeList;
setPreferenceProperty( hierarchy_type, "strings", aHierarchyTypeList );
setPreferenceProperty( hierarchy_type, "indexes", aHierarchyTypeIndexesList );
- addPreference( tr( "GEOM_MOVE_POSSIBILITY" ), DependencyViewId,
+ addPreference( tr( "GEOM_MOVE_POSSIBILITY" ), treeGeneralGroup,
LightApp_Preferences::Bool, "Geometry", "dependency_tree_move_nodes" );
int treeColorGroup = addPreference( tr( "PREF_GROUP_DEPENDENCY_VIEW_COLOR" ), DependencyViewId );
LightApp_Preferences::Color, "Geometry", "dependency_tree_node_color" );
addPreference( tr( "PREF_DEPENDENCY_VIEW_MAIN_NODE_COLOR"), treeColorGroup,
LightApp_Preferences::Color, "Geometry", "dependency_tree_main_node_color" );
+ addPreference( tr( "PREF_DEPENDENCY_VIEW_UNPUBLISH_NODE_COLOR"), treeColorGroup,
+ LightApp_Preferences::Color, "Geometry", "dependency_tree_unpublish_node_color" );
addPreference( tr( "PREF_DEPENDENCY_VIEW_SELECT_NODE_COLOR"), treeColorGroup,
LightApp_Preferences::Color, "Geometry", "dependency_tree_select_node_color" );
param == QString("scalar_bar_nb_intervals")) {
if( SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( getApp()->activeStudy() ) )
{
- GEOM_Displayer aDisplayer( aStudy );
- bool anIsRedisplayFieldSteps = param == QString("scalar_bar_nb_intervals");
- aDisplayer.UpdateColorScale( anIsRedisplayFieldSteps, true );
+ updateFieldColorScale();
}
}
- else if ( param == QString("dimensions_color") ||
- param == QString("dimensions_line_width") ||
- param == QString("dimensions_font_height") ||
- param == QString("dimensions_arrow_length") ||
- param == QString("dimensions_show_units") ||
- param == QString("dimensions_length_units") ||
- param == QString("dimensions_angle_units") )
+ else if ( param == QString("dimensions_color") ||
+ param == QString("dimensions_line_width") ||
+ param == QString("dimensions_font") ||
+ param == QString("dimensions_arrow_length") ||
+ param == QString("dimensions_show_units") ||
+ param == QString("dimensions_length_units") ||
+ param == QString("dimensions_angle_units") ||
+ param == QString("dimensions_use_text3d") ||
+ param == QString("shape_annotation_font_color") ||
+ param == QString("shape_annotation_line_color") ||
+ param == QString("shape_annotation_font") ||
+ param == QString("shape_annotation_line_width") ||
+ param == QString("shape_annotation_autohide") ||
+ param == QString("shape_annotation_line_style") ||
+ param == QString("shape_annotation_line_style") ||
+ param == QString("label_color") )
{
SalomeApp_Application* anApp = getApp();
if ( !anApp )
SALOME_ListIO aVisible;
aViewer->GetVisible( aVisible );
- aDisplayer.Redisplay( aVisible, false, aViewer );
- }
- aDisplayer.UpdateViewer();
- }
- else if ( param.startsWith( "dependency_tree") )
- {
- SalomeApp_Application* app = getApp();
- if ( !app ) return;
-
- SUIT_ViewManager *svm = app->getViewManager( GraphicsView_Viewer::Type(), false );
- if( !svm ) return;
-
- if( DependencyTree_ViewModel* viewModel = dynamic_cast<DependencyTree_ViewModel*>( svm->getViewModel() ) )
- if( DependencyTree_View* view = dynamic_cast<DependencyTree_View*>( viewModel->getActiveViewPort() ) ) {
- if( param == QString("dependency_tree_hierarchy_type") ) {
- int hierarchyType = aResourceMgr->integerValue( section, param, 0);
- view->setHierarchyType( hierarchyType );
- }
- else if( param == QString("dependency_tree_move_nodes") ) {
- bool isNodesMovable = aResourceMgr->booleanValue( section, param, true);
- view->setNodesMovable( isNodesMovable );
- }
- else if( param == QString("dependency_tree_background_color") ) {
- QColor c = aResourceMgr->colorValue( section, param, QColor( 255, 255, 255 ) );
- view->setPrefBackgroundColor( c );
- }
- else if( param == QString("dependency_tree_node_color") ) {
- QColor c = aResourceMgr->colorValue( section, param, QColor( 62, 180, 238 ) );
- view->setNodeColor( c );
- }
- else if( param == QString("dependency_tree_main_node_color") ) {
- QColor c = aResourceMgr->colorValue( section, param, QColor( 238, 90, 125 ) );
- view->setMainNodeColor( c );
- }
- else if( param == QString("dependency_tree_select_node_color") ) {
- QColor c = aResourceMgr->colorValue( section, param, QColor( 237, 243, 58 ) );
- view->setSelectNodeColor( c );
- }
- else if( param == QString("dependency_tree_arrow_color") ) {
- QColor c = aResourceMgr->colorValue( section, param, QColor( 0, 0, 130 ) );
- view->setArrowColor( c );
- }
- else if( param == QString("dependency_tree_highlight_arrow_color") ) {
- QColor c = aResourceMgr->colorValue( section, param, QColor( 0, 0, 255 ) );
- view->setHighlightArrowColor( c );
- }
- else if( param == QString("dependency_tree_select_arrow_color") ) {
- QColor c = aResourceMgr->colorValue( section, param, QColor( 255, 0, 0 ) );
- view->setSelectArrowColor( c );
+ GEOMGUI_AnnotationMgr* anAnnotationMgr = GetAnnotationMgr();
+ if ( anAnnotationMgr ) {
+ SALOME_ListIteratorOfListIO anIter( aVisible );
+ while ( anIter.More() ) {
+ if ( anAnnotationMgr->isAnnotationEntry( anIter.Value()->getEntry() ) ) {
+ aVisible.Remove( anIter );
+ }
+ else {
+ anIter.Next();
+ }
}
+ }
+ aDisplayer.Redisplay( aVisible, false, aViewer );
+ }
+ if ( param == QString( "label_color" ) ) {
+ ViewManagerList aVMsVTK;
+ anApp->viewManagers( SVTK_Viewer::Type(), aVMsVTK );
+ ViewManagerList::Iterator anIt = aVMsVTK.begin();
+ for ( ; anIt != aVMsVTK.end(); ++anIt )
+ {
+ SVTK_Viewer* aViewer = dynamic_cast<SVTK_Viewer*>( (*anIt)->getViewModel() );
+ if ( !aViewer )
+ {
+ continue;
+ }
+ SALOME_ListIO aVisible;
+ aViewer->GetVisible( aVisible );
+ aDisplayer.Redisplay( aVisible, false, aViewer );
+ }
}
+ aDisplayer.UpdateViewer();
}
+ else if ( param.startsWith( "dependency_tree") )
+ emit SignalDependencyTreeParamChanged( section, param );
}
}
SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
if ( !appStudy || !appStudy->studyDS() )
return;
+
_PTR(Study) studyDS = appStudy->studyDS();
// componentName is used for encoding of entries when storing them in IParameters
QList<SUIT_ViewManager*> lst;
QList<SUIT_ViewManager*>::Iterator it;
+ GEOMGUI_AnnotationMgr* aAnnotationMgr = GetAnnotationMgr();
+
// main cycle to store parameters of displayed objects
lst.clear();
getApp()->viewManagers(lst);
for (it = lst.begin(); it != lst.end(); it++) {
SUIT_ViewManager* vman = *it;
QString vType = vman->getType();
+ SUIT_ViewModel* vmodel = vman->getViewModel();
+ SALOME_View* aView = dynamic_cast<SALOME_View*>(vmodel);
+
int aMgrId = vman->getGlobalId();
// saving VTK actors properties
QVector<SUIT_ViewWindow*> views = vman->getViews();
for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++) {
- const ObjMap anObjects = appStudy->getObjectMap(aMgrId);
+ const ObjMap& anObjects = appStudy->getObjectProperties(aMgrId);
ObjMap::ConstIterator o_it = anObjects.begin();
for (; o_it != anObjects.end(); o_it++) {
- const PropMap aProps = o_it.value();
+ 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
+ // entry is "encoded" = it does NOT contain component address, since it is a
// subject to change on next component loading
std::string entry = ip->encodeEntry(o_it.key().toLatin1().data(), componentName);
ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::EdgesDirection )).toString().toStdString());
}
+ if (aProps.contains(GEOM::propertyName( GEOM::Vertices ))) {
+ param = occParam + GEOM::propertyName( GEOM::Vertices );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::Vertices )).toString().toStdString());
+ }
+
+ if (aProps.contains(GEOM::propertyName( GEOM::ShowName ))) {
+ param = occParam + GEOM::propertyName( GEOM::ShowName );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::ShowName )).toString().toStdString());
+ }
+
if (aProps.contains(GEOM::propertyName( GEOM::Deflection ))) {
param = occParam + GEOM::propertyName( GEOM::Deflection );
ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::Deflection )).toString().toStdString());
param = occParam + GEOM::propertyName( GEOM::IsosWidth );
ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::IsosWidth )).toString().toStdString());
}
+
+ if ( vType == SOCC_Viewer::Type() && aAnnotationMgr ) {
+ std::string anAnnotationInfo = GetAnnotationMgr()->getDisplayedIndicesInfo(
+ o_it.key().toLatin1().data(), dynamic_cast<SOCC_Viewer*>(aView) ).toStdString();
+ if (!anAnnotationInfo.empty()) {
+ param = occParam + "ShapeAnnotationVisibleItems";
+ ip->setParameter(entry, param.toStdString(), anAnnotationInfo);
+ }
+ }
} // object iterator
} // for (views)
} // for (viewManagers)
- // store dimension attributes of objects:
+ // store shape annotation and dimension attributes of objects:
// since the displayed object always persists in property map, we remember the object entries
// on the passes when we store viewer related properties - to avoid extra iterations on GEOM component tree.
- QString aDimensionParam = OCCViewer_Viewer::Type() + GEOM::sectionSeparator() + GEOM::propertyName( GEOM::Dimensions );
+ const QString aDimensionParam = OCCViewer_Viewer::Type() + GEOM::sectionSeparator() + GEOM::propertyName( GEOM::Dimensions );
+ const QString aAnnotationParam = OCCViewer_Viewer::Type() + GEOM::sectionSeparator() + GEOM::propertyName( GEOM::ShapeAnnotations );
QSet<QString>::ConstIterator aEntryIt = anEntriesToStoreShared.constBegin();
for ( ; aEntryIt != anEntriesToStoreShared.constEnd(); ++aEntryIt )
{
std::string aStudyEntry = (*aEntryIt).toLatin1().data();
- std::string aStoreEntry = ip->encodeEntry( aStudyEntry, componentName);
+ std::string aStoreEntry = ip->encodeEntry( aStudyEntry, componentName );
+ // store dimension parameters
GEOMGUI_DimensionProperty aDimensions( appStudy, aStudyEntry );
-
- if ( aDimensions.GetNumber() == 0 )
- {
- continue;
+ if ( aDimensions.GetNumber() != 0 ) {
+ ip->setParameter( aStoreEntry, aDimensionParam.toStdString(), ((QString)aDimensions).toLatin1().data() );
}
- ip->setParameter( aStoreEntry, aDimensionParam.toStdString(), ((QString)aDimensions).toLatin1().data() );
+ _PTR(SObject) aObj( studyDS->FindObjectID( aStudyEntry ) );
+ const Handle(GEOMGUI_AnnotationAttrs) aShapeAnnAttr = GEOMGUI_AnnotationAttrs::FindAttributes( aObj );
+ if ( !aShapeAnnAttr.IsNull() ) {
+ ip->setParameter( aStoreEntry, aAnnotationParam.toStdString(), aShapeAnnAttr->ExportAsPropertyString().toLatin1().data() );
+ }
}
}
for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
{
- // entry is a normal entry - it should be "decoded" (setting base adress of component)
+ // entry is a normal entry - it should be "decoded" (setting base address of component)
QString entry (ip->decodeEntry(*entIt).c_str());
// Check that the entry corresponds to a real object in the Study
GEOMGUI_DimensionProperty aDimensionProp( aValuesStr );
aDimensionProp.SaveToAttribute( appStudy, entry.toLatin1().data() );
}
+ else if ( aParamNameStr == GEOM::propertyName( GEOM::ShapeAnnotations ) )
+ {
+ Handle(GEOMGUI_AnnotationAttrs) anAttr =
+ GEOMGUI_AnnotationAttrs::FindOrCreateAttributes( so, appStudy );
+
+ anAttr->ImportFromPropertyString( aValuesStr );
+ }
continue;
}
aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::Texture ), val );
} else if (paramNameStr == GEOM::propertyName( GEOM::EdgesDirection )) {
aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::EdgesDirection ), val == "true" || val == "1");
+ } else if (paramNameStr == GEOM::propertyName( GEOM::Vertices )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::Vertices ), val == "true" || val == "1");
+ } else if (paramNameStr == GEOM::propertyName( GEOM::ShowName )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::ShowName ), val == "true" || val == "1");
} else if (paramNameStr == GEOM::propertyName( GEOM::Deflection )) {
aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::Deflection ), val.toDouble());
} else if (paramNameStr == GEOM::propertyName( GEOM::PointMarker )) {
aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::LineWidth ), val.toInt());
} else if (paramNameStr == GEOM::propertyName( GEOM::IsosWidth )) {
aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::IsosWidth ), val.toInt());
+ } else if (paramNameStr == "ShapeAnnotationVisibleItems") {
+ aListOfMap[viewIndex].insert( "ShapeAnnotationVisibleItems", val);
}
+
} // for names/parameters iterator
QList<SUIT_ViewManager*> lst = getApp()->viewManagers();
for (int index = 0; index < aListOfMap.count(); index++) {
-
- appStudy->setObjectPropMap(index, entry, aListOfMap[index]);
+ appStudy->setObjectProperties(index, entry, aListOfMap[index]);
//Get Visibility property of the current PropMap
if (aListOfMap[index].value(GEOM::propertyName( GEOM::Visibility )) == 1) {
SUIT_ViewManager* vman = lst.at(index);
SUIT_ViewModel* vmodel = vman->getViewModel();
- displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
+ SALOME_View* aView = dynamic_cast<SALOME_View*>(vmodel);
+ displayer()->Display(entry, true, aView);
+
+ if ( vmodel->getType() == SOCC_Viewer::Type() ) {
+ PropMap& aProps = aListOfMap[index];
+ if ( aProps.contains( "ShapeAnnotationVisibleItems" ) ) {
+ SOCC_Viewer* aSOCCView = dynamic_cast<SOCC_Viewer*>( aView );
+ GetAnnotationMgr()->setDisplayedIndicesInfo( entry, aSOCCView, aProps["ShapeAnnotationVisibleItems"].toString() );
+ }
+ }
}
}
} // for entries iterator
occVMod->Repaint();
}
}
+
+ if ( myTextTreeWdg ) {
+ myTextTreeWdg->updateTree();
+ }
+}
+
+// Compute current name mode of the viewer
+void UpdateNameMode( SalomeApp_Application* app )
+{
+ bool isMode = false;
+ SalomeApp_Study* aStudy = dynamic_cast< SalomeApp_Study* >( app->activeStudy() );
+ SUIT_ViewWindow* viewWindow = app->desktop()->activeWindow();
+ GEOM_Displayer displayer( aStudy );
+ int aMgrId = viewWindow->getViewManager()->getGlobalId();
+
+ SALOME_View* window = displayer.GetActiveView();
+ if ( !window ) return;
+
+ SALOME_ListIO anIOlst;
+ window->GetVisible( anIOlst );
+
+ for ( SALOME_ListIteratorOfListIO It( anIOlst ); It.More(); It.Next() ) {
+ Handle( SALOME_InteractiveObject ) io = It.Value();
+ QVariant v = aStudy->getObjectProperty( aMgrId, io->getEntry(), GEOM::propertyName( GEOM::ShowName ), QVariant() );
+ bool isIONameMode = v.isValid() ? v.toBool() : false;
+ if( isIONameMode )
+ isMode = true;
+ }
+ viewWindow->setProperty( "NameMode", isMode );
}
void GeometryGUI::onViewAboutToShow()
{
SUIT_ViewWindow* window = application()->desktop()->activeWindow();
QAction* a = action( GEOMOp::OpSwitchVectors );
+ QAction* aVerticesAction = action( GEOMOp::OpSwitchVertices );
+ QAction* aNameAction = action( GEOMOp::OpSwitchName );
if ( window ) {
a->setEnabled(true);
bool vmode = window->property("VectorsMode").toBool();
a->setText ( vmode == 1 ? tr( "MEN_VECTOR_MODE_OFF" ) : tr("MEN_VECTOR_MODE_ON") );
+ aVerticesAction->setEnabled(true);
+ vmode = window->property("VerticesMode").toBool();
+ aVerticesAction->setText ( vmode == 1 ? tr( "MEN_VERTICES_MODE_OFF" ) : tr("MEN_VERTICES_MODE_ON") );
+ UpdateNameMode( getApp() );
+ aNameAction->setEnabled(true);
+ vmode = window->property("NameMode").toBool();
+ aNameAction->setText ( vmode == 1 ? tr( "MEN_NAME_MODE_OFF" ) : tr("MEN_NAME_MODE_ON") );
} else {
a->setText ( tr("MEN_VECTOR_MODE_ON") );
a->setEnabled(false);
+ aVerticesAction->setText ( tr("MEN_VERTICES_MODE_ON") );
+ aVerticesAction->setEnabled(false);
+ aNameAction->setText ( tr("MEN_NAME_MODE_ON") );
+ aNameAction->setEnabled(false);
}
}
GEOM::GEOM_Object_var anObj = GEOM::GEOM_Object::_narrow(GeometryGUI::ClientSObjectToObject(obj));
if (!CORBA::is_nil(anObj)) {
anObj->SetName( name.toLatin1().data() ); // Rename the corresponding GEOM_Object
- // rename the given object in the dependency tree
- if ( SUIT_ViewManager *svm = app->getViewManager( GraphicsView_Viewer::Type(), false ) )
- if ( DependencyTree_ViewModel* viewModel = dynamic_cast<DependencyTree_ViewModel*>( svm->getViewModel() ) )
- if ( DependencyTree_View* view = dynamic_cast<DependencyTree_View*>( viewModel->getActiveViewPort() ) )
- view->updateObjectName( anObj->GetEntry() );
+ emit SignalDependencyTreeRenameObject( anObj->GetEntry() );
+ emit SignalTextTreeRenameObject( entry );
}
result = true;
}
// update Object browser
getApp()->updateObjectBrowser( false );
}
+
+void GeometryGUI::emitDimensionsUpdated( QString entry )
+{
+ emit DimensionsUpdated( entry );
+}
+
+void GeometryGUI::emitAnnotationsUpdated( QString entry )
+{
+ emit SignalAnnotationsUpdated( entry );
+}
