// SMESH includes
#include "SMESHGUI.h"
+#include "SMESHGUI_AdaptDlg.h"
#include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
#include "SMESHGUI_AddMeshElementDlg.h"
#include "SMESHGUI_AddQuadraticElementDlg.h"
#include "SMESH_version.h"
-#include "SMESH_ControlsDef.hxx"
#include "SMESH_Actor.h"
#include "SMESH_ActorUtils.h"
#include "SMESH_Client.hxx"
+#include "SMESH_Comment.hxx"
+#include "SMESH_ControlsDef.hxx"
#include "SMESH_ScalarBarActor.h"
-#include <SMESH_Comment.hxx>
#include "SMESH_TypeFilter.hxx"
// SALOME GUI includes
#include <LightApp_UpdateFlags.h>
#include <QtxFontEdit.h>
#include <QtxPopupMgr.h>
+#include <QtxInfoPanel.h>
#include <SALOME_ListIO.hxx>
#include <SUIT_Desktop.h>
#include <SUIT_FileDlg.h>
int objectCount = 0;
QString aNameList;
QString aParentComponent = QString::null;
-
+
for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
{
Handle(SALOME_InteractiveObject) anIO = anIt.Value();
if ( anIO.IsNull() ) continue;
-
+
QString father = "unknown", name;
_PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
OCC_CATCH_SIGNALS;
SMESH::UpdateView();
}
- catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
+ catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
SMESH::OnVisuException();
}
catch (...) { // PAL16774 (Crash after display of many groups)
case SMESHOp::OpMeshOrder:
case SMESHOp::OpCreateSubMesh:
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
-
+ break; // action forbidden as geometry modified
+ // fall through
case SMESHOp::OpCreateMesh:
case SMESHOp::OpCompute:
case SMESHOp::OpComputeSubMesh:
case SMESHOp::OpPreCompute:
case SMESHOp::OpEvaluate:
+ case SMESHOp::OpShowErrors:
startOperation( theCommandID );
break;
+ case SMESHOp::OpRecompute:
+ {
+ if ( isStudyLocked() )
+ break;
+ SALOME_ListIO selected;
+ if ( LightApp_SelectionMgr *sel = selectionMgr() )
+ sel->selectedObjects( selected );
+ if ( selected.Extent() == 1 ) {
+ SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
+ if ( !aMesh->_is_nil() )
+ aMesh->Clear();
+ startOperation( SMESHOp::OpCompute );
+ }
+ }
+ break;
case SMESHOp::OpCopyMesh:
{
if (isStudyLocked()) break;
if ( isStudyLocked() )
break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
/*Standard_Boolean aRes;
SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
if ( isStudyLocked() )
break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
EmitSignalDeactivateDialog();
SMESHGUI_MultiEditDlg* aDlg = NULL;
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_SmoothingDlg( this ) )->show();
{
if (isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if (vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_ExtrusionDlg ( this ) )->show();
{
if (isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if (vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RevolutionDlg( this ) )->show();
if ( isStudyLocked() )
break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd )
{
EmitSignalDeactivateDialog();
}
break;
}
+ // Adaptation - begin
+ case SMESHOp::OpUniformRefinement:
+ case SMESHOp::OpHONewCase:
+ case SMESHOp::OpHOCaseFollow:
+ case SMESHOp::OpHONewIter:
+ case SMESHOp::OpHOIterCompute:
+ case SMESHOp::OpHOIterComputePublish:
+ case SMESHOp::OpHOEdit:
+ case SMESHOp::OpHODelete:
+ case SMESHOp::OpMGAdapt:
+ {
+ SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
+ SMESHGUI_AdaptDlg *objet = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
+ }
+ // Adaptation - end
case SMESHOp::OpSplitBiQuadratic:
case SMESHOp::OpConvertMeshToQuadratic:
case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
case SMESHOp::OpCreateGeometryGroup:
{
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
startOperation( theCommandID );
break;
}
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
EmitSignalDeactivateDialog();
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
EmitSignalDeactivateDialog();
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
EmitSignalDeactivateDialog();
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
if ( isStudyLocked() )
break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
EmitSignalDeactivateDialog();
if ( isStudyLocked() )
break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
EmitSignalDeactivateDialog();
SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
if ( isStudyLocked() )
break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
EmitSignalDeactivateDialog();
SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
SALOME_ListIO selected;
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
SUIT_OverrideCursor wc;
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
SMDSAbs_EntityType type = SMDSEntity_Edge;
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
SMDSAbs_EntityType type = SMDSEntity_Last;
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RemoveNodesDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RemoveElementsDlg( this ) )->show();
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
SALOME_ListIO selected;
if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
SALOME_ListIO selected;
if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
aSel->selectedObjects( selected );
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_TranslationDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_RotationDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if(vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_SymmetryDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_ScaleDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_OffsetDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if(vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_SewingDlg( this ) )->show();
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if(vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_MergeDlg( this, 0 ) )->show();
{
if (isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if (vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_MergeDlg( this, 1 ) )->show();
case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
startOperation( SMESHOp::OpMoveNode );
break;
{
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
if ( warnOnGeomModif() )
- break; // action forbiden as geometry modified
+ break; // action forbidden as geometry modified
startOperation( SMESHOp::OpElem0DOnElemNodes );
break;
*
*/
//=============================================================================
-bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return false;
}
*
*/
//=============================================================================
-bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return true;
}
*
*/
//=============================================================================
-bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return true;
}
if ( !icon_id.isEmpty() )
pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
else
- pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
+ pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
if ( !pix.isNull() )
icon = QIcon( pix );
createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
+ createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
+ createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
+ // Adaptation - begin
+ createSMESHAction( SMESHOp::OpUniformRefinement, "REF_ALL", "ICON_REF_ALL" );
+ createSMESHAction( SMESHOp::OpHONewCase, "HOMARD_CREATE_CASE", "ICON_HOMARD_CREATE_CASE" );
+ createSMESHAction( SMESHOp::OpHOCaseFollow, "HOMARD_FOLLOW_ITERATION", "ICON_HOMARD_FOLLOW_ITERATION" );
+ createSMESHAction( SMESHOp::OpHONewIter, "HOMARD_NEW_ITERATION", "ICON_HOMARD_NEW_ITERATION" );
+ createSMESHAction( SMESHOp::OpHOIterCompute, "HOMARD_COMPUTE", "ICON_HOMARD_COMPUTE" );
+ createSMESHAction( SMESHOp::OpHOIterComputePublish, "HOMARD_COMPUTE_PUBLISH", "ICON_HOMARD_COMPUTE_PUBLISH" );
+ createSMESHAction( SMESHOp::OpHOEdit, "EDIT", "ICON_DLG_EDIT_MESH" );
+ createSMESHAction( SMESHOp::OpHODelete, "DELETE", "ICON_DELETE" );
+ createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
+ // Adaptation - end
+
createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
+ adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
//renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
+ refHomardId = createMenu( tr( "MEN_REF_HOMARD" ), adaptId, -1, 10 ),
basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
//createMenu( SMESHOp::OpImportDAT, importId, -1 );
createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
+ // Adaptation - begin
+ createMenu( SMESHOp::OpUniformRefinement, adaptId, -1 );
+ createMenu( SMESHOp::OpHONewCase, refHomardId, -1 );
+ createMenu( SMESHOp::OpHOCaseFollow, refHomardId, -1 );
+ createMenu( separator(), refHomardId, -1 );
+ createMenu( SMESHOp::OpHONewIter, refHomardId, -1 );
+ createMenu( SMESHOp::OpHOIterCompute, refHomardId, -1 );
+ createMenu( SMESHOp::OpHOIterComputePublish, refHomardId, -1 );
+ createMenu( separator(), refHomardId, -1 );
+ createMenu( SMESHOp::OpHOEdit, refHomardId, -1 );
+ createMenu( SMESHOp::OpHODelete, refHomardId, -1 );
+ createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
+ // Adaptation - end
+
createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
createMenu( SMESHOp::OpAngle, measureId, -1 );
connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
// ----- create toolbars --------------
- int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
- info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
- groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
- ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
- ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
- ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
- ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
- addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
- addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
- remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
- //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
- transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
- modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
- measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
- dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
-
+ int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
createTool( SMESHOp::OpCreateMesh, meshTb );
createTool( SMESHOp::OpCreateSubMesh, meshTb );
createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
createTool( SMESHOp::OpEvaluate, meshTb );
createTool( SMESHOp::OpMeshOrder, meshTb );
+ int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
+ createTool( SMESHOp::OpMeshInformation, infoTb );
+ //createTool( SMESHOp::OpStdInfo, meshTb );
+ //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
+ createTool( SMESHOp::OpFindElementByPoint, infoTb );
+
+ int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
createTool( SMESHOp::OpCreateGroup, groupTb );
createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
createTool( SMESHOp::OpConstructGroup, groupTb );
createTool( SMESHOp::OpEditGroup, groupTb );
- createTool( SMESHOp::OpMeshInformation, info );
- //createTool( SMESHOp::OpStdInfo, meshTb );
- //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
- createTool( SMESHOp::OpFindElementByPoint, info );
-
+ int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
createTool( SMESHOp::OpFreeNode, ctrl0dTb );
createTool( SMESHOp::OpEqualNode, ctrl0dTb );
//createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
+ int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
createTool( SMESHOp::OpLength, ctrl1dTb );
createTool( SMESHOp::OpConnection, ctrl1dTb );
createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
+ int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
createTool( SMESHOp::OpFreeFace, ctrl2dTb );
createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
createTool( SMESHOp::OpEqualFace, ctrl2dTb );
createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
+ int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
createTool( SMESHOp::OpVolume, ctrl3dTb );
createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
+ int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
createTool( SMESHOp::OpNode, addElemTb );
createTool( SMESHOp::OpElem0D, addElemTb );
createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
createTool( SMESHOp::OpHexagonalPrism, addElemTb );
createTool( SMESHOp::OpPolyhedron, addElemTb );
+ int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
+ int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
createTool( SMESHOp::OpRemoveNodes, remTb );
createTool( SMESHOp::OpRemoveElements, remTb );
createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
createTool( SMESHOp::OpClearMesh, remTb );
+// int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
//createTool( SMESHOp::OpRenumberingNodes, renumbTb );
//createTool( SMESHOp::OpRenumberingElements, renumbTb );
+ int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
createTool( SMESHOp::OpMergeNodes, transformTb );
createTool( SMESHOp::OpMergeElements, transformTb );
createTool( SMESHOp::OpTranslation, transformTb );
createTool( SMESHOp::OpSewing, transformTb );
createTool( SMESHOp::OpDuplicateNodes, transformTb );
+ int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
createTool( SMESHOp::OpExtrusion, modifyTb );
createTool( SMESHOp::OpSmoothing, modifyTb );
createTool( SMESHOp::OpPatternMapping, modifyTb );
+ // Adaptation - begin
+ int adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ) ;
+ createTool( SMESHOp::OpUniformRefinement, adaptTb );
+ createTool( SMESHOp::OpHONewCase, adaptTb );
+ createTool( SMESHOp::OpHOCaseFollow, adaptTb );
+ createTool( SMESHOp::OpHONewIter, adaptTb );
+ createTool( SMESHOp::OpHOIterCompute, adaptTb );
+ createTool( SMESHOp::OpHOIterComputePublish, adaptTb );
+ createTool( SMESHOp::OpMGAdapt, adaptTb );
+ // Adaptation - end
+
+ int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
createTool( SMESHOp::OpMinimumDistance, measuremTb );
+ int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
createTool( SMESHOp::OpUpdate, dispModeTb );
QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
hasVolumes("({'Volume'} in elemTypes)"),
hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
- createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
- createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
+ createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
+ createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
createPopupItem( SMESHOp::OpEditGroup, OB, group );
createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
popupMgr()->insert( separator(), -1, 0 );
- createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
- createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
- createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
- createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
- createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
- createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
+ createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
+ createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
+ createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
+ createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
+ createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
+ createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
+ popupMgr()->insert( separator(), -1, 0 );
+ createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
- createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
+ createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
popupMgr()->insert( separator(), -1, 0 );
- createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
+ createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
popupMgr()->insert( separator(), -1, 0 );
- createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
- //popupMgr()->insert( separator(), -1, 0 );
+
+ // Adaptation - begin
+ createPopupItem( SMESHOp::OpUniformRefinement, OB, mesh );
+ createPopupItem( SMESHOp::OpHONewCase, OB, mesh );
+// createPopupItem( SMESHOp::OpHOCaseFollow, OB, mesh );
+// createPopupItem( SMESHOp::OpHONewIter, OB, mesh );
+// createPopupItem( SMESHOp::OpHOIterCompute, OB, mesh );
+// createPopupItem( SMESHOp::OpHOIterComputePublish, OB, mesh );
+ createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
+ // Adaptation - end
QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
QString only_one_2D = only_one_non_empty + " && dim>1";
int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
+ popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
- createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
- createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
popupMgr()->insert( separator(), -1, 0 );
+ createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
+ createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
+ createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
+
// popup for viewer
createPopupItem( SMESHOp::OpEditGroup, View, group );
createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
popupMgr()->insert( separator(), -1, 0 );
- createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
- createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
+ createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
popupMgr()->insert( separator(), -1, 0 );
+ createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
popupMgr()->insert( separator(), -1, 0 );
SALOME_ListIteratorOfListIO It( selected );
for ( ; isCompatible && It.More(); It.Next())
isCompatible =
- ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
- ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
+ ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
+ ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
+ ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
return isCompatible;
}
bool SMESHGUI::reusableOperation( const int id )
{
// compute, evaluate and precompute are not reusable operations
- return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
+ return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
+}
+
+namespace
+{
+ QString wrap(const QString& text, const QString& tag)
+ { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
}
bool SMESHGUI::activateModule( SUIT_Study* study )
setMenuShown( true );
setToolShown( true );
+ // Fill in Help Panel
+ SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
+ app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
+
+ int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
+ QString lab;
+ QStringList items;
+ lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
+ lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
+ lab = lab + tr("INFO_COMPUTE") + "<br/>";
+ lab = lab + tr("INFO_REFINE") + ":";
+ items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
+ << wrap(tr("INFO_REFINE_SUBMESH"), "li");
+ lab = lab + wrap(items.join(""), "ul");
+ items.clear();
+
+ app->infoPanel()->addLabel(lab, gb);
+
+ gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
+ items << wrap("UNV", "li")
+ << wrap("MED", "li")
+ << wrap("STL", "li")
+ << wrap("CGNS", "li")
+ << wrap("SAUV", "li")
+ << wrap("GMF", "li");
+ lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
+ items.clear();
+
+ app->infoPanel()->addLabel(lab, gb);
+
+ gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
+ lab = tr("INFO_DISPLAY") + "<br/>";
+ items << wrap(tr("INFO_QUALITY_AREA"), "li")
+ << wrap(tr("INFO_QUALITY_VOLUME"), "li")
+ << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
+ << wrap("...", "li");
+ lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
+ items.clear();
+ lab = lab + tr("INFO_CLIPPING");
+
+ app->infoPanel()->addLabel(lab, gb);
+ // << Help Panel
+
// import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
PyGILState_STATE gstate = PyGILState_Ensure();
PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
{
aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
+ aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
#ifndef DISABLE_PYCONSOLE
aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
#endif
void SMESHGUI::ProcessEvents( vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
- void* theCallData )
+ void* /*theCallData*/ )
{
if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
setPreferenceProperty( dispgroup, "columns", 2 );
addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
-
+
int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
QStringList modes;
modes.append( tr("MEN_WIRE") );
setPreferenceProperty( coloringType, "indexes", indices );
addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
+ // Adaptation - begin
+ // Adaptation tab ------------------------------------------------------------------------
+ int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
+ int bloc, pref ;
+ // Refinement with HOMARD
+ bloc = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION" ), adaptTab );
+ setPreferenceProperty( bloc, "columns", 1 );
+ pref = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION_MAILLAGE_IN" ), bloc, LightApp_Preferences::Bool, "HOMARD", "homard_publish_mesh_in" );
+ pref = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "homard_publish_mesh_out" );
+
+ // YACS with HOMARD
+ bloc = addPreference( tr( "ADAPT_PREF_HOMARD_YACS" ), adaptTab );
+ setPreferenceProperty( bloc, "columns", 1 );
+ pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_ITER" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_iter" );
+ setPreferenceProperty( pref, "min", 0 );
+ setPreferenceProperty( pref, "max", 100000000 );
+ setPreferenceProperty( pref, "step", 1 );
+ pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_NODE" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_node" );
+ setPreferenceProperty( pref, "min", 0 );
+ setPreferenceProperty( pref, "max", 100000000 );
+ setPreferenceProperty( pref, "step", 1000 );
+ pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_ELEM" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_elem" );
+ setPreferenceProperty( pref, "min", 0 );
+ setPreferenceProperty( pref, "max", 100000000 );
+ setPreferenceProperty( pref, "step", 1000 );
+ pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_TYPE_CONVERGENCE" ), bloc, LightApp_Preferences::Selector, "HOMARD", "homard_yacs_type_test" );
+ QStringList aListOfTypeTest;
+ aListOfTypeTest << tr( "ADAPT_PREF_NONE" );
+ aListOfTypeTest << "VTest > VRef";
+ aListOfTypeTest << "VTest < VRef";
+ setPreferenceProperty( pref, "strings", aListOfTypeTest );
+
+ // MG-Adapt
+ bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
+ setPreferenceProperty( bloc, "columns", 1 );
+ pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
+ pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
+ pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
+ QStringList aListOfSizeMap;
+ aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
+ aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
+ aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
+ setPreferenceProperty( pref, "strings", aListOfSizeMap );
+ pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
+ QStringList aListOfTimeStep;
+ aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
+ aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
+ aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
+ setPreferenceProperty( pref, "strings", aListOfTimeStep );
+ // Adaptation - end
+
}
void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
// to do : create operation here
switch( id )
{
- case SMESHOp::OpSplitBiQuadratic:
- op = new SMESHGUI_SplitBiQuadOp();
+ case SMESHOp::OpSplitBiQuadratic:
+ op = new SMESHGUI_SplitBiQuadOp();
break;
- case SMESHOp::OpConvertMeshToQuadratic:
- op = new SMESHGUI_ConvToQuadOp();
+ case SMESHOp::OpConvertMeshToQuadratic:
+ op = new SMESHGUI_ConvToQuadOp();
break;
- case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
- op = new SMESHGUI_Make2DFrom3DOp();
+ case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
+ op = new SMESHGUI_Make2DFrom3DOp();
break;
- case SMESHOp::OpReorientFaces:
- op = new SMESHGUI_ReorientFacesOp();
- break;
- case SMESHOp::OpCreateMesh:
- op = new SMESHGUI_MeshOp( true, true );
+ case SMESHOp::OpReorientFaces:
+ op = new SMESHGUI_ReorientFacesOp();
break;
- case SMESHOp::OpCreateSubMesh:
- op = new SMESHGUI_MeshOp( true, false );
+ case SMESHOp::OpCreateMesh:
+ op = new SMESHGUI_MeshOp( true, true );
break;
- case SMESHOp::OpEditMeshOrSubMesh:
- case SMESHOp::OpEditMesh:
- case SMESHOp::OpEditSubMesh:
- op = new SMESHGUI_MeshOp( false );
+ case SMESHOp::OpCreateSubMesh:
+ op = new SMESHGUI_MeshOp( true, false );
break;
- case SMESHOp::OpCompute:
- case SMESHOp::OpComputeSubMesh:
- op = new SMESHGUI_ComputeOp();
+ case SMESHOp::OpEditMeshOrSubMesh:
+ case SMESHOp::OpEditMesh:
+ case SMESHOp::OpEditSubMesh:
+ op = new SMESHGUI_MeshOp( false );
break;
- case SMESHOp::OpPreCompute:
- op = new SMESHGUI_PrecomputeOp();
+ case SMESHOp::OpCompute:
+ case SMESHOp::OpComputeSubMesh:
+ op = new SMESHGUI_ComputeOp();
break;
- case SMESHOp::OpEvaluate:
- op = new SMESHGUI_EvaluateOp();
+ case SMESHOp::OpShowErrors:
+ op = new SMESHGUI_ShowErrorsOp();
break;
- case SMESHOp::OpMeshOrder:
- op = new SMESHGUI_MeshOrderOp();
+ case SMESHOp::OpPreCompute:
+ op = new SMESHGUI_PrecomputeOp();
break;
- case SMESHOp::OpCreateGeometryGroup:
- op = new SMESHGUI_GroupOnShapeOp();
- break;
- case SMESHOp::OpFindElementByPoint:
- op = new SMESHGUI_FindElemByPointOp();
- break;
- case SMESHOp::OpMoveNode: // Make mesh pass through point
- op = new SMESHGUI_MakeNodeAtPointOp();
- break;
- case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
- op = new SMESHGUI_Add0DElemsOnAllNodesOp();
- break;
- default:
+ case SMESHOp::OpEvaluate:
+ op = new SMESHGUI_EvaluateOp();
+ break;
+ case SMESHOp::OpMeshOrder:
+ op = new SMESHGUI_MeshOrderOp();
+ break;
+ case SMESHOp::OpCreateGeometryGroup:
+ op = new SMESHGUI_GroupOnShapeOp();
+ break;
+ case SMESHOp::OpFindElementByPoint:
+ op = new SMESHGUI_FindElemByPointOp();
+ break;
+ case SMESHOp::OpMoveNode: // Make mesh pass through point
+ op = new SMESHGUI_MakeNodeAtPointOp();
+ break;
+ case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
+ op = new SMESHGUI_Add0DElemsOnAllNodesOp();
+ break;
+ // Adaptation - begin
+ case SMESHOp::OpUniformRefinement:
+ case SMESHOp::OpHONewCase:
+ case SMESHOp::OpHOCaseFollow:
+ case SMESHOp::OpHONewIter:
+ case SMESHOp::OpHOIterCompute:
+ case SMESHOp::OpHOIterComputePublish:
+ case SMESHOp::OpHOEdit:
+ case SMESHOp::OpHODelete:
+ case SMESHOp::OpMGAdapt:
+ break;
+ // Adaptation - end
+ default:
break;
}
// componentName is used for encoding of entries when storing them in IParameters
std::string componentName = myComponentSMESH->ComponentDataType();
- //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
- //if (!aSComponent) return;
// IParameters
_PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
