-// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "SMESHGUI.h"
#include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
#include "SMESHGUI_AddMeshElementDlg.h"
+#include "SMESHGUI_AddNodeOnSegmentDlg.h"
+#include "SMESHGUI_AddNodeOnFaceDlg.h"
#include "SMESHGUI_AddQuadraticElementDlg.h"
#include "SMESHGUI_BuildCompoundDlg.h"
#include "SMESHGUI_ClippingDlg.h"
#include "SMESHGUI_MG_ADAPTDRIVER.h"
#include "SMESHGUI_HomardAdaptDlg.h"
#include "SMESHGUI_Make2DFrom3DOp.h"
+#include "SMESHGUI_MakeFull2DFrom3DOp.h"
#include "SMESHGUI_MakeNodeAtPointDlg.h"
#include "SMESHGUI_Measurements.h"
#include "SMESHGUI_MergeDlg.h"
#include "SMESHGUI_Preferences_ScalarBarDlg.h"
#include "SMESHGUI_PropertiesDlg.h"
#include "SMESHGUI_RemoveElementsDlg.h"
+#include "SMESHGUI_RemoveNodeReconnectionDlg.h"
#include "SMESHGUI_RemoveNodesDlg.h"
#include "SMESHGUI_RenumberingDlg.h"
#include "SMESHGUI_ReorientFacesDlg.h"
#include "SMESHGUI_SymmetryDlg.h"
#include "SMESHGUI_TranslationDlg.h"
#include "SMESHGUI_TransparencyDlg.h"
+#include "SMESHGUI_CreateDualMeshDlg.h"
+#include "SMESHGUI_CreateDualMeshOp.h"
#include "SMESHGUI_Utils.h"
#include "SMESHGUI_VTKUtils.h"
#include "SMESH_ControlsDef.hxx"
#include "SMESH_ScalarBarActor.h"
#include "SMESH_TypeFilter.hxx"
-#include "SMESH_Component_Generator.hxx"
// SALOME GUI includes
#include <LightApp_DataOwner.h>
type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
type = QObject::tr( "WARP_ELEMENTS" );
+ else if (dynamic_cast<SMESH::Controls::Warping3D*>(f.get()))
+ type = QObject::tr("WARP_3D_ELEMENTS");
else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
type = QObject::tr( "TAPER_ELEMENTS" );
else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
type = QObject::tr( "EQUAL_VOLUME" );
else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
type = QObject::tr( "NODE_CONNECTIVITY_NB" );
+ else if ( dynamic_cast< SMESH::Controls::ScaledJacobian* >( f.get() ) )
+ type = QObject::tr( "SCALED_JACOBIAN" );
return type;
}
ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
+ ActionControl.Bind( SMESHOp::OpWarping3D, SMESH_Actor::eWarping3D );
ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
+ ActionControl.Bind( SMESHOp::OpScaledJacobian, SMESH_Actor::eScaledJacobian );
ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
aStudyBuilder->RemoveObjectWithChildren( SO );
}
- else {// default action: remove SObject from the study
- // Find Sub-Meshes and Group and delete corresopning visual objects and actors
- _PTR(ChildIterator) it1 = aStudy->NewChildIterator(SO);
- for (it1->InitEx(false); it1->More(); it1->Next()) {
- _PTR(SObject) SObj = it1->Value();
- if (!SObj) continue;
- if (SObj->FindAttribute(anAttr, "AttributeIOR")) {
- SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(SMESH::SObjectToObject(SObj));
- SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow(SMESH::SObjectToObject(SObj));
- if (!aGroup->_is_nil() || !aSubMesh->_is_nil()) {
- SMESH::RemoveVisualObjectWithActors(SObj->GetID().c_str(), true);
- }
- }
- }
+ else {// default action: remove SObject from the study
+ // Find Sub-Meshes and Group and delete corresopning visual objects and actors
+ _PTR(ChildIterator) it1 = aStudy->NewChildIterator(SO);
+ for (it1->InitEx(false); it1->More(); it1->Next()) {
+ _PTR(SObject) SObj = it1->Value();
+ if (!SObj) continue;
+ if (SObj->FindAttribute(anAttr, "AttributeIOR")) {
+ SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(SMESH::SObjectToObject(SObj));
+ SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow(SMESH::SObjectToObject(SObj));
+ if (!aGroup->_is_nil() || !aSubMesh->_is_nil()) {
+ SMESH::RemoveVisualObjectWithActors(SObj->GetID().c_str(), true);
+ }
+ }
+ }
// san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
//SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
//op->start();
if ( CORBA::is_nil( myComponentSMESH ) )
{
CORBA::Boolean anIsEmbeddedMode;
- SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
- if( dynamic_cast<SALOME_NamingService *>(ns) )
- myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
- else
- {
- Engines::EngineComponent_var comp = RetrieveSMESHInstance();
- myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
- }
-
+ myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
+
//MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
// 0019923: EDF 765 SMESH : default values of hypothesis
break;
}
#endif
+#ifndef DISABLE_HOMARD_ADAPT
case SMESHOp::OpHomardAdapt:
{
if ( isStudyLocked() )
}
break;
}
+#endif
// Adaptation - end
case SMESHOp::OpSplitBiQuadratic:
case SMESHOp::OpConvertMeshToQuadratic:
+ case SMESHOp::OpCreateDualMesh:
case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
+ case SMESHOp::OpCreate2DElements: // create full 2D mesh from 3D
case SMESHOp::OpReorientFaces:
case SMESHOp::OpCreateGeometryGroup:
{
}
break;
}
+ case SMESHOp::OpRemoveNodeWithReconn:
+ {
+ if(isStudyLocked()) break;
+ if ( warnOnGeomModif() )
+ break; // action forbidden as geometry modified
+ startOperation( SMESHOp::OpRemoveNodeWithReconn );
+ break;
+ }
case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
{
if(isStudyLocked()) break;
startOperation( SMESHOp::OpMoveNode );
break;
+ case SMESHOp::OpMoveNodeInteractive:
+ if ( warnOnGeomModif() )
+ break; // action forbidden as geometry modified
+ startOperation( SMESHOp::OpMoveNodeInteractive );
+ break;
+
+ case SMESHOp::OpSplitEdgeInteract:
+ if ( warnOnGeomModif() )
+ break; // action forbidden as geometry modified
+ startOperation( SMESHOp::OpSplitEdgeInteract );
+ break;
+
+ case SMESHOp::OpSplitFaceInteract:
+ if ( warnOnGeomModif() )
+ break; // action forbidden as geometry modified
+ startOperation( SMESHOp::OpSplitFaceInteract );
+ break;
+
case SMESHOp::OpDuplicateNodes:
{
if(isStudyLocked()) break;
case SMESHOp::OpMaxElementLength2D:
case SMESHOp::OpEqualFace:
case SMESHOp::OpAspectRatio3D:
+ case SMESHOp::OpWarping3D:
case SMESHOp::OpVolume:
+ case SMESHOp::OpScaledJacobian:
case SMESHOp::OpMaxElementLength3D:
case SMESHOp::OpBareBorderVolume:
case SMESHOp::OpOverConstrainedVolume:
createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
+ createSMESHAction( SMESHOp::OpWarping3D, "WARP_3D", "ICON_WARP", 0, true);
createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
+ createSMESHAction( SMESHOp::OpScaledJacobian, "SCALED_JACOBIAN", "ICON_SCALED_JACOBIAN", 0, true );
createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
+ createSMESHAction( SMESHOp::OpRemoveNodeWithReconn, "REMOVE_NODE_RECON", "ICON_REM_NODE_RECON" );
createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
//createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
+ createSMESHAction( SMESHOp::OpMoveNodeInteractive, "MOVE_NODE_INTRCT","ICON_DLG_MOVE_NODE_INTERACTIVE" );
+ createSMESHAction( SMESHOp::OpSplitEdgeInteract, "SPLIT_DIAG_INTRC","ICON_SPLIT_DIAG_INTERACTIVE" );
+ createSMESHAction( SMESHOp::OpSplitFaceInteract, "SPLIT_FACE_INTRC","ICON_SPLIT_FACE_INTERACTIVE" );
createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
+ createSMESHAction( SMESHOp::OpCreateDualMesh, "CREATE_DUAL_MESH","ICON_CREATE_DUAL_MESH" );
createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
+ createSMESHAction( SMESHOp::OpCreate2DElements, "2D_FROM_3D_ELEMENTS","ICON_2D_FROM_3D_ELEMENTS" );
createSMESHAction( SMESHOp::OpReset, "RESET" );
createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
#ifndef DISABLE_MG_ADAPT
createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
#endif
+#ifndef DISABLE_HOMARD_ADAPT
createSMESHAction( SMESHOp::OpHomardAdapt, "HOMARD_ADAPT", "ICON_HOMARD_ADAPT" );
+#endif
// Adaptation - end
createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
<< SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
<< SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
<< SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
- << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
+ << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume << SMESHOp::OpWarping3D
<< SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
- << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
+ << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume << SMESHOp::OpScaledJacobian; // volume controls
QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
aCtrlGroup->setExclusive( true );
for( int i = 0; i < aCtrlActions.size(); i++ )
meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
-#ifndef DISABLE_MG_ADAPT
+#if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
#endif
measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
+ createMenu( SMESHOp::OpCreateDualMesh, meshId, -1 );
createMenu( separator(), meshId, -1 );
createMenu( SMESHOp::OpCompute, meshId, -1 );
createMenu( SMESHOp::OpPreCompute, meshId, -1 );
createMenu( SMESHOp::OpEqualFace, faceId, -1 );
createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
+ createMenu( SMESHOp::OpWarping3D, volumeId, -1 );
createMenu( SMESHOp::OpVolume, volumeId, -1 );
createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
+ createMenu( SMESHOp::OpScaledJacobian, volumeId, -1 );
createMenu( separator(), ctrlId, -1 );
createMenu( SMESHOp::OpReset, ctrlId, -1 );
createMenu( separator(), ctrlId, -1 );
createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
-
- createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
- createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
- createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
- createMenu( separator(), removeId, -1 );
- createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
- createMenu( separator(), removeId, -1 );
- createMenu( SMESHOp::OpClearMesh, removeId, -1 );
+ createMenu( separator(), addId, -1 );
+ createMenu( SMESHOp::OpSplitEdgeInteract, addId, -1 );
+ createMenu( SMESHOp::OpSplitFaceInteract, addId, -1 );
+
+ createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
+ createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
+ createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
+ createMenu( SMESHOp::OpRemoveNodeWithReconn, removeId, -1 );
+ createMenu( separator(), removeId, -1 );
+ createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
+ createMenu( separator(), removeId, -1 );
+ createMenu( SMESHOp::OpClearMesh, removeId, -1 );
//createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
//createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
+ createMenu( SMESHOp::OpCreate2DElements, modifyId, -1 );
createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
createMenu( SMESHOp::OpRevolution, modifyId, -1 );
#ifndef DISABLE_MG_ADAPT
createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
#endif
+#ifndef DISABLE_HOMARD_ADAPT
createMenu( SMESHOp::OpHomardAdapt, adaptId, -1 );
+#endif
// Adaptation - end
createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
+ createTool( SMESHOp::OpWarping3D, ctrl3dTb );
createTool( SMESHOp::OpVolume, ctrl3dTb );
createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
+ createTool( SMESHOp::OpScaledJacobian, ctrl3dTb );
int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
createTool( SMESHOp::OpNode, addElemTb );
int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
+ createTool( SMESHOp::OpCreate2DElements, modifyTb );
createTool( SMESHOp::OpExtrusion, modifyTb );
createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
createTool( SMESHOp::OpRevolution, modifyTb );
createTool( SMESHOp::OpSmoothing, modifyTb );
createTool( SMESHOp::OpPatternMapping, modifyTb );
+ int interactTb = createTool( tr( "TB_INTERACT" ), QString( "SMESHInteractiveToolbar" ) ) ;
+ createTool( SMESHOp::OpMoveNodeInteractive, interactTb );
+ createTool( SMESHOp::OpRemoveNodeWithReconn, interactTb );
+ createTool( SMESHOp::OpSplitEdgeInteract, interactTb );
+ createTool( SMESHOp::OpSplitFaceInteract, interactTb );
+
// Adaptation - begin
-#ifndef DISABLE_MG_ADAPT
+#if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
+#endif
+#ifndef DISABLE_MG_ADAPT
createTool( SMESHOp::OpMGAdapt, adaptTb );
#endif
+#ifndef DISABLE_HOMARD_ADAPT
createTool( SMESHOp::OpHomardAdapt, adaptTb );
+#endif
// Adaptation - end
int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
#ifndef DISABLE_MG_ADAPT
createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
#endif
+#ifndef DISABLE_HOMARD_ADAPT
createPopupItem( SMESHOp::OpHomardAdapt, OB, mesh );
+#endif
popupMgr()->insert( separator(), -1, 0 );
// Adaptation - end
popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
+ popupMgr()->insert ( action( SMESHOp::OpWarping3D ), aSubId, -1 );
+ popupMgr()->setRule( action( SMESHOp::OpWarping3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
+ popupMgr()->setRule( action( SMESHOp::OpWarping3D), "controlMode = 'eWarping3D'", QtxPopupMgr::ToggleRule );
+
popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
+ popupMgr()->insert ( action( SMESHOp::OpScaledJacobian ), aSubId, -1 );
+ popupMgr()->setRule( action( SMESHOp::OpScaledJacobian ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
+ popupMgr()->setRule( action( SMESHOp::OpScaledJacobian ), "controlMode = 'eScaledJacobian'", QtxPopupMgr::ToggleRule );
+
popupMgr()->insert( separator(), anId, -1 );
popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
op = new SMESHGUI_Make2DFrom3DOp();
break;
+ case SMESHOp::OpCreateDualMesh:
+ op = new SMESHGUI_CreateDualMeshOp();
+ break;
+ case SMESHOp::OpCreate2DElements:
+ op = new SMESHGUI_MakeFull2DFrom3DOp();
+ break;
case SMESHOp::OpReorientFaces:
op = new SMESHGUI_ReorientFacesOp();
break;
case SMESHOp::OpMoveNode: // Make mesh pass through point
op = new SMESHGUI_MakeNodeAtPointOp();
break;
+ case SMESHOp::OpMoveNodeInteractive: // Make mesh pass through point / by mouse
+ op = new SMESHGUI_MakeNodeAtPointOp( 2 );
+ break;
+ case SMESHOp::OpRemoveNodeWithReconn:
+ op = new SMESHGUI_RemoveNodeReconnectionOp();
+ break;
+ case SMESHOp::OpSplitEdgeInteract:
+ op = new SMESHGUI_AddNodeOnSegmentOp();
+ break;
+ case SMESHOp::OpSplitFaceInteract:
+ op = new SMESHGUI_AddNodeOnFaceOp();
+ break;
case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
op = new SMESHGUI_Add0DElemsOnAllNodesOp();
break;
