-// Copyright (C) 2007-2020 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
// File : SMESHGUI.cxx
// Author : Nicolas REJNERI, Open CASCADE S.A.S.
+#include <Basics_OCCTVersion.hxx>
+
+#if OCC_VERSION_LARGE < 0x07080000
+
#include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
+
+#else
+
+#ifdef _MSC_VER
+#ifndef _USE_MATH_DEFINES
+#define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#endif
+
+#endif
+
#ifdef HAVE_FINITE
#undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
#endif
// SMESH includes
#include "SMESHGUI.h"
-#include "SMESHGUI_AdaptDlg.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_GroupUtils.h"
#include "SMESHGUI_Hypotheses.h"
#include "SMESHGUI_HypothesesUtils.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_MeshInfo.h"
+#include "SMESHGUI_Meshio.h"
#include "SMESHGUI_MeshOp.h"
#include "SMESHGUI_MeshOrderOp.h"
#include "SMESHGUI_MeshPatternDlg.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 <LightApp_UpdateFlags.h>
#include <QtxFontEdit.h>
#include <QtxPopupMgr.h>
+#include <QtxInfoPanel.h>
#include <SALOME_ListIO.hxx>
#include <SUIT_Desktop.h>
#include <SUIT_FileDlg.h>
#include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
#include CORBA_CLIENT_HEADER(SMESH_Measurements)
#include CORBA_CLIENT_HEADER(SMESH_Mesh)
+#include CORBA_CLIENT_HEADER(SMESH_Homard)
// Qt includes
// #define INCLUDE_MENUITEM_DEF // VSR commented ????????
#include <vtkRenderer.h>
// SALOME KERNEL includes
+#include <Basics_Utils.hxx>
#include <SALOMEDSClient_ClientFactory.hxx>
#include <SALOMEDSClient_IParameters.hxx>
#include <SALOMEDSClient_SComponent.hxx>
#include <SALOMEDSClient_StudyBuilder.hxx>
-#include <SALOMEDS_Study.hxx>
#include <SALOMEDS_SObject.hxx>
-#include "utilities.h"
+#include <SALOMEDS_Study.hxx>
+#include <SALOME_GenericObj_wrap.hxx>
#include <SALOME_LifeCycleCORBA.hxx>
+#include <utilities.h>
// OCCT includes
#include <Standard_ErrorHandler.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_DoubleMap.hxx>
-#include <Basics_Utils.hxx>
-
// Below macro, when uncommented, switches on simplified (more performant) algorithm
// of auto-color picking up
#define SIMPLE_AUTOCOLOR
void Control( int theCommandID );
// Definitions
+
//================================================================================
/*!
* \brief Reads meshes from file
theCommandID == SMESHOp::OpPopupImportCGNS ) {
filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
}
- else if ( theCommandID == SMESHOp::OpImportSAUV ||
- theCommandID == SMESHOp::OpPopupImportSAUV ) {
- filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
- filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
- }
else if ( theCommandID == SMESHOp::OpImportGMF ||
theCommandID == SMESHOp::OpPopupImportGMF ) {
filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
}
+ else if (theCommandID == SMESHOp::OpImportMESHIO) {
+ if (!SMESHGUI_Meshio::IsMeshioInstalled())
+ return;
+
+ filter = SMESHGUI_Meshio::GetImportFileFilter();
+ }
QString anInitialPath = "";
if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
}
break;
}
- case SMESHOp::OpImportSAUV:
- case SMESHOp::OpPopupImportSAUV:
- {
- // SAUV format
- SMESH::DriverMED_ReadStatus res;
- aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
- if ( res != SMESH::DRS_OK ) {
- errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
- arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
- }
- break;
- }
case SMESHOp::OpImportGMF:
case SMESHOp::OpPopupImportGMF:
{
}
break;
}
+ case SMESHOp::OpImportMESHIO:
+ {
+ aMeshes = SMESHGUI_Meshio::ImportMesh(theComponentMesh, filename, errors);
+ break;
+ }
}
}
catch ( const SALOME::SALOME_Exception& S_ex ) {
- errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
- arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
+ const QString exText(S_ex.details.text);
+ if (exText.startsWith("MESHIO"))
+ errors.append('\n' + exText);
+ else
+ errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
+ arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
}
for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
theCommandID == SMESHOp::OpPopupExportSTL );
const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
theCommandID == SMESHOp::OpPopupExportCGNS );
- const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
- theCommandID == SMESHOp::OpPopupExportSAUV );
const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
theCommandID == SMESHOp::OpPopupExportGMF );
+ const bool isMESHIO = (theCommandID == SMESHOp::OpExportMESHIO);
+
+ if (isMESHIO && !SMESHGUI_Meshio::IsMeshioInstalled())
+ {
+ return;
+ }
- const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
+ const bool multiMeshSupported = isMED || isCGNS || isMESHIO; // file can hold several meshes
if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
return;
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
bool aCheckWarn = true;
if ( resMgr )
aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
+
// get mesh object from selection and check duplication of their names
bool hasDuplicatedMeshNames = false;
QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
QString aMeshName = (*aMeshIter).second;
- if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
+ if (isMED || isCGNS || isMESHIO) // formats where group names must be unique
{
// check for equal group names within each mesh
for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
{
format = "CGNS";
notSupportedElemTypes.push_back( SMESH::Entity_Ball );
- }
- else if ( isSAUV )
- {
- format = "SAUV";
- notSupportedElemTypes.push_back( SMESH::Entity_Ball );
- notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
- notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
- notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
- notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
- notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
- notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
- notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
- }
+ }
else if ( isGMF )
{
format = "GMF";
}
if ( ! notSupportedElemTypes.empty() )
{
- SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
+ SMESH::smIdType_array_var nbElems = aMeshOrGroup->GetMeshInfo();
for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
"SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
};
// is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
- const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
- int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
+ static_assert( sizeof(typeMsg) / sizeof(const char*) == SMESH::Entity_Last,
+ "Update names of EntityType's!!!" );
QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
// Get parameters of export operation
QString aFilename;
+ QString aSelectedFilter; // for meshio to get a filter selected by user
int aFormat =-1; // for MED version used for write
bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
// Init the parameters with the default values
bool aIsASCII_STL = true;
- bool toCreateGroups = false;
- if ( resMgr )
- toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
- bool toOverwrite = true;
- bool toFindOutDim = true;
- double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
+ bool toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
+ bool toOverwrite = true;
+ bool toFindOutDim = true;
+ bool saveNumbers = resMgr->booleanValue( "SMESH", "med_save_numbers", true );
+ bool toRenumber = true;
+ bool structureCGNS = false;
+ double zTol = resMgr->doubleValue( "SMESH", "med_ztolerance", 0. );
QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
QString anInitialPath = "";
QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
// Get a file name to write in and additional options
- if ( isUNV || isDAT || isGMF ) // Export w/o options
+ if ( isGMF ) // Export w/o options
{
- if ( isUNV )
- aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
- else if ( isDAT )
- aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
- else if ( isGMF )
- aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
- ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
- if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
+ aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
+ ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
+ if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
+
aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
anInitialPath + QString("/") + aMeshName,
aFilter, aTitle, false);
}
- else if ( isCGNS )// Export to CGNS
+ else if ( isCGNS )
+ {
+ const char* theOptionResource = "cgns_group_elems_by_type";
+ bool option = resMgr->booleanValue( "SMESH", theOptionResource, false );
+
+ QStringList checkBoxes;
+ checkBoxes << QObject::tr( "CGNS_EXPORT_ELEMS_BY_TYPE" ) << QObject::tr("STRUCTUREDCGNS");
+
+ SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
+
+ fd->setWindowTitle( aTitle );
+ fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
+
+ if ( !anInitialPath.isEmpty() )
+ fd->setDirectory( anInitialPath );
+ fd->selectFile( aMeshName );
+ SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
+ fd->setValidator( fv );
+ fd->SetChecked( option, 0 );
+
+ if ( fd->exec() )
+ {
+ aFilename = fd->selectedFile();
+ structureCGNS = fd->IsChecked( 1 );
+ }
+
+ toOverwrite = fv->isOverwrite( aFilename );
+ option = fd->IsChecked( 0 );
+ SMESHGUI::resourceMgr()->setValue("SMESH", theOptionResource, option );
+ toCreateGroups = option;
+
+ delete fd;
+ }
+ else if ( isUNV || isDAT ) // Export to [ UNV | DAT ] - one option
{
- const char* theByTypeResource = "cgns_group_elems_by_type";
- toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
+ const char* theOptionResource = "export_renumber";
+ bool option = resMgr->booleanValue( "SMESH", theOptionResource, false );
QStringList checkBoxes;
- checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
+ checkBoxes << QObject::tr( "SMESH_RENUMBER" );
SalomeApp_CheckFileDlg* fd =
new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
fd->setWindowTitle( aTitle );
- fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
+ if ( isUNV )
+ fd->setNameFilter( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
+ else if ( isDAT )
+ fd->setNameFilter( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
if ( !anInitialPath.isEmpty() )
fd->setDirectory( anInitialPath );
- fd->selectFile(aMeshName);
+ fd->selectFile( aMeshName );
SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
fd->setValidator( fv );
- fd->SetChecked( toCreateGroups, 0 );
+ fd->SetChecked( option, 0 );
if ( fd->exec() )
aFilename = fd->selectedFile();
- toOverwrite = fv->isOverwrite(aFilename);
- toCreateGroups = fd->IsChecked(0);
- SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
+ toOverwrite = fv->isOverwrite( aFilename );
+ option = fd->IsChecked( 0 );
+ SMESHGUI::resourceMgr()->setValue("SMESH", theOptionResource, option );
+ toRenumber = option;
delete fd;
}
else if ( isSTL ) // Export to STL
{
QMap<QString, int> aFilterMap;
+ QStringList filters;
aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
-
- QStringList filters;
+
QMap<QString, int>::const_iterator it = aFilterMap.begin();
for ( ; it != aFilterMap.end(); ++it )
- filters.push_back( it.key() );
-
+ filters.push_back( it.key() );
+
SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
fd->setWindowTitle( aTitle );
fd->setNameFilters( filters );
- fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
+
if ( !anInitialPath.isEmpty() )
fd->setDirectory( anInitialPath );
fd->selectFile(aMeshName);
while (!is_ok) {
if ( fd->exec() )
aFilename = fd->selectedFile();
- aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
+ if ( isSTL )
+ aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
is_ok = true;
}
delete fd;
}
- else if ( isMED || isSAUV ) // Export to MED or SAUV
+ else if ( isMED ) // Export to MED
{
int defaultVersion = 0;
QMap<QString, int> aFilterMap;
- if ( isMED ) {
- //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
- //QString vmed (aMesh->GetVersionString(-1, 2));
- SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
- if ( mvok->length() > 0)
- defaultVersion = mvok[0]; // the current version to set the default filter on it
- for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
- {
- QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
- MESSAGE("MED version: " << vs.toStdString());
- aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
- }
- }
- else { // isSAUV
- aFilterMap.insert("All files (*)", -1 );
- aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
- aFilterMap.insert("SAUV files (*.sauve)", -1 );
+ //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
+ //QString vmed (aMesh->GetVersionString(-1, 2));
+ SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
+ if ( mvok->length() > 0)
+ defaultVersion = mvok[0]; // the current version to set the default filter on it
+ for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
+ {
+ QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
+ aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
}
QStringList filters;
QMap<QString, int>::const_iterator it = aFilterMap.begin();
aDefaultFilter = it.key();
}
QStringList checkBoxes;
- checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
+ checkBoxes << QObject::tr("SMESH_AUTO_GROUPS")
+ << QObject::tr("SMESH_AUTO_DIM")
+ << QObject::tr("SMESH_MED_SAVE_NUMS");
SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
QList< QWidget* > wdgList;
fd->selectNameFilter( aDefaultFilter );
fd->SetChecked( toCreateGroups, 0 );
fd->SetChecked( toFindOutDim, 1 );
+ fd->SetChecked( saveNumbers, 2 );
if ( !anInitialPath.isEmpty() )
fd->setDirectory( anInitialPath );
fd->selectFile(aMeshName);
}
toCreateGroups = fd->IsChecked(0);
toFindOutDim = fd->IsChecked(1);
+ saveNumbers = fd->IsChecked(2);
zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
fieldSelWdg->GetSelectedFields();
if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
delete zTolWdg;
delete fd;
}
+ else if (isMESHIO)
+ {
+ if (SMESHGUI_Meshio::CheckMeshCount(aMeshList))
+ {
+ aFilename = SMESHGUI_Meshio::GetFileName(aSelectedFilter);
+ MESSAGE("aSelectedFilter: " << aSelectedFilter.toStdString());
+ }
+ }
else
{
return;
// if ( SMESHGUI::automaticUpdate() )
// SMESH::UpdateView();
// }
- if ( isMED && isOkToWrite)
+ if ( isMED && isOkToWrite )
{
- MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
aMeshIter = aMeshList.begin();
for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
{
SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
- const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
- if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
- aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
- toOverwrite && aMeshIndex == 0, toFindOutDim );
- else
- aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
- toCreateGroups, aFormat,
- toOverwrite && aMeshIndex == 0, toFindOutDim,
- fields, geoAssFields.toLatin1().data(), zTol );
- }
- }
- else if ( isSAUV )
- {
- for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
- {
- SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
- if( !aMeshItem->_is_nil() )
- aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
+
+ aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
+ toCreateGroups, aFormat,
+ toOverwrite && aMeshIndex == 0, toFindOutDim,
+ fields, geoAssFields.toLatin1().data(), zTol, saveNumbers );
}
}
else if ( isDAT )
{
if ( aMeshOrGroup->_is_equivalent( aMesh ))
- aMesh->ExportDAT( aFilename.toUtf8().data() );
+ aMesh->ExportDAT( aFilename.toUtf8().data(), toRenumber );
else
- aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
+ aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
}
else if ( isUNV )
{
if ( aMeshOrGroup->_is_equivalent( aMesh ))
- aMesh->ExportUNV( aFilename.toUtf8().data() );
+ aMesh->ExportUNV( aFilename.toUtf8().data(), toRenumber );
else
- aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
+ aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
}
else if ( isSTL )
{
else if ( isCGNS )
{
aMeshIter = aMeshList.begin();
+
for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
{
SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
- aMeshItem->ExportCGNS( aMeshOrGroup,
- aFilename.toUtf8().data(),
- toOverwrite && aMeshIndex == 0,
- toCreateGroups );
+
+ if ( !structureCGNS )
+ aMeshItem->ExportCGNS( aMeshOrGroup,
+ aFilename.toUtf8().data(),
+ toOverwrite && aMeshIndex == 0,
+ toCreateGroups );
+ else
+ aMeshItem->ExportStructuredCGNS( aMeshOrGroup,
+ aFilename.toUtf8().data(),
+ toOverwrite && aMeshIndex == 0 );
}
}
else if ( isGMF )
toCreateGroups = true;
aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
}
+ else if (isMESHIO)
+ {
+ SMESHGUI_Meshio::ExportMesh(aMeshList, aFilename, aSelectedFilter);
+ }
}
- catch (const SALOME::SALOME_Exception& S_ex){
+ catch (const SALOME::SALOME_Exception& S_ex)
+ {
wc.suspend();
- SUIT_MessageBox::warning(SMESHGUI::desktop(),
- QObject::tr("SMESH_WRN_WARNING"),
- QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
+ const QString exText(S_ex.details.text);
+
+ if ( S_ex.details.type == SALOME::COMM && // communicate about too large mesh
+ strncmp( "format=", S_ex.details.sourceFile.in(), 7 ) == 0 )
+
+ SUIT_MessageBox::critical(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr(S_ex.details.text.in() ));
+ else if (exText.startsWith("MESHIO"))
+ {
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr("SMESH_EXPORT_FAILED_SHORT") + "\n\n" + exText);
+ }
+ else if ( isMED )
+ {
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
+ }
+ else
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ SalomeApp_Tools::ExceptionToString(S_ex));
wc.resume();
}
}
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;
}
SMESH::Controls::NumericalFunctor* aNumFun =
dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
if ( aNumFun ) {
- std::vector<int> elements;
+ std::vector<smIdType> elements;
SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
if ( mesh->_is_nil() ) {
SMESH::SMESH_IDSource_var idSource =
SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
if ( !idSource->_is_nil() )
{
- SMESH::long_array_var ids = idSource->GetIDs();
+ SMESH::smIdType_array_var ids = idSource->GetIDs();
elements.resize( ids->length() );
for ( unsigned i = 0; i < elements.size(); ++i )
elements[i] = ids[i];
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 );
if ( anActor->GetControlMode() != aControl )
anActor->SetControlMode( aControl );
QString functorName = functorToString( anActor->GetFunctor() );
- int anEntitiesCount = anActor->GetNumberControlEntities();
+ smIdType anEntitiesCount = anActor->GetNumberControlEntities();
if (anEntitiesCount >= 0)
functorName = functorName + ": " + QString::number(anEntitiesCount);
anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
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);
+ }
+ }
+ }
// 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();
*
*/
//=============================================================================
-SMESHGUI::SMESHGUI() :
-SalomeApp_Module( "SMESH" )
+SMESHGUI::SMESHGUI() : SalomeApp_Module( "SMESH" )
{
if ( CORBA::is_nil( myComponentSMESH ) )
{
CORBA::Boolean anIsEmbeddedMode;
myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
+
//MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
// 0019923: EDF 765 SMESH : default values of hypothesis
long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
- SMESH::long_array_var info = theMesh->GetMeshInfo();
+ SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
long nbOdElems = info[SMDSEntity_0D];
long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
//QAction* act = action( theCommandID );
+ bool logAction(false);
switch (theCommandID) {
case SMESHOp::OpDelete:
case SMESHOp::OpImportMED:
case SMESHOp::OpImportSTL:
case SMESHOp::OpImportCGNS:
- case SMESHOp::OpImportSAUV:
case SMESHOp::OpImportGMF:
+ case SMESHOp::OpImportMESHIO:
case SMESHOp::OpPopupImportDAT:
case SMESHOp::OpPopupImportUNV:
case SMESHOp::OpPopupImportMED:
case SMESHOp::OpPopupImportSTL:
case SMESHOp::OpPopupImportCGNS:
- case SMESHOp::OpPopupImportSAUV:
case SMESHOp::OpPopupImportGMF:
{
if(isStudyLocked()) break;
case SMESHOp::OpExportUNV:
case SMESHOp::OpExportSTL:
case SMESHOp::OpExportCGNS:
- case SMESHOp::OpExportSAUV:
case SMESHOp::OpExportGMF:
+ case SMESHOp::OpExportMESHIO:
case SMESHOp::OpPopupExportDAT:
case SMESHOp::OpPopupExportMED:
case SMESHOp::OpPopupExportUNV:
case SMESHOp::OpPopupExportSTL:
case SMESHOp::OpPopupExportCGNS:
- case SMESHOp::OpPopupExportSAUV:
case SMESHOp::OpPopupExportGMF:
{
::ExportMeshToFile(theCommandID);
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:
break;
case SMESHOp::OpCopyMesh:
{
+ logAction = true;
if (isStudyLocked()) break;
EmitSignalDeactivateDialog();
( new SMESHGUI_CopyMeshDlg( this ) )->show();
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:
+#ifndef DISABLE_MG_ADAPT
case SMESHOp::OpMGAdapt:
{
- SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
- SMESHGUI_AdaptDlg *objet = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
+ if ( isStudyLocked() )
+ break;
+ EmitSignalDeactivateDialog();
+
+ SALOME::GenericObj_wrap< SMESH::MG_ADAPT > model = GetSMESHGen()->CreateMG_ADAPT();
+ bool isCreation = false;
+ ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
+ break;
+ }
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+ case SMESHOp::OpHomardAdapt:
+ {
+ if ( isStudyLocked() )
+ break;
+ EmitSignalDeactivateDialog();
+
+ SALOME::GenericObj_wrap< SMESHHOMARD::HOMARD_Gen > homardGen;
+ try {
+ homardGen = GetSMESHGen()->CreateHOMARD_ADAPT();
+ }
+ catch ( const SALOME::SALOME_Exception& S_ex ) {
+ SUIT_MessageBox::critical(SMESHGUI::desktop(),
+ QObject::tr("SMESH_ERROR"),
+ QObject::tr(S_ex.details.text.in()));
+ }
+ if (!homardGen->_is_nil()) {
+ SMESHGUI_HomardAdaptDlg *aDlg = new SMESHGUI_HomardAdaptDlg(homardGen);
+ aDlg->show();
+ }
+ 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:
{
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();
try {
SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
// get submesh elements list by types
- SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
- SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
- SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
- SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
+ SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
+ SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
+ SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
+ SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
// create group for each type o elements
QString aName = IObject->getName();
QStringList anEntryList;
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();
}
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;
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 );
try {
SUIT_OverrideCursor wc;
SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
- int removed = aMeshEditor->RemoveOrphanNodes();
+ smIdType removed = aMeshEditor->RemoveOrphanNodes();
SUIT_MessageBox::information(SMESHGUI::desktop(),
tr("SMESH_INFORMATION"),
tr("NB_NODES_REMOVED").arg(removed));
{
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();
}
case SMESHOp::OpTranslation:
{
+ logAction = true;
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();
}
case SMESHOp::OpRotation:
{
+ logAction = true;
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();
}
case SMESHOp::OpSymmetry:
{
+ logAction = true;
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();
}
case SMESHOp::OpScale:
{
+ logAction = true;
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();
case SMESHOp::OpOffset:
{
+ logAction = true;
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();
case SMESHOp::OpSewing:
{
+ logAction = true;
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;
+ 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;
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;
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:
anApp->updateActions(); //SRN: To update a Save button in the toolbar
//updateObjBrowser();
+ if(logAction)
+ {
+ QAction* anAction = action( theCommandID );
+ CAM_Application::logStructuredUserEvent( "Mesh",
+ "Operation",
+ anAction->text(),
+ "activated" );
+ }
return true;
}
*
*/
//=============================================================================
-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;
}
pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
if ( !pix.isNull() )
icon = QIcon( pix );
-
+
QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
#endif
- createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
+ createSMESHAction( SMESHOp::OpImportMESHIO, "IMPORT_MESHIO" );
createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
#endif
- createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
#endif
- createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
+ createSMESHAction( SMESHOp::OpExportMESHIO, "EXPORT_MESHIO" );
createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
#endif
- createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
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" );
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" );
+#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 ),
+#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 ),
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 );
+ // Import menu
//createMenu( SMESHOp::OpImportDAT, importId, -1 );
createMenu( SMESHOp::OpImportUNV, importId, -1 );
createMenu( SMESHOp::OpImportMED, importId, -1 );
#ifdef WITH_CGNS
createMenu( SMESHOp::OpImportCGNS, importId, -1 );
#endif
- createMenu( SMESHOp::OpImportSAUV, importId, -1 );
createMenu( SMESHOp::OpImportGMF, importId, -1 );
+ createMenu( SMESHOp::OpImportMESHIO, importId, -1 ); // formats supported by meshio lib
+
+ // Export menu
createMenu( SMESHOp::OpExportDAT, exportId, -1 );
createMenu( SMESHOp::OpExportMED, exportId, -1 );
createMenu( SMESHOp::OpExportUNV, exportId, -1 );
#ifdef WITH_CGNS
createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
#endif
- createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
createMenu( SMESHOp::OpExportGMF, exportId, -1 );
+ createMenu( SMESHOp::OpExportMESHIO, exportId, -1 ); // formats supported by meshio lib
createMenu( separator(), fileId, 10 );
createMenu( SMESHOp::OpDelete, editId, -1 );
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 );
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 );
+#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 );
connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
// ----- create toolbars --------------
- int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
+ 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" ) ) ;
+ 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" ) ) ;
+ int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
createTool( SMESHOp::OpCreateGroup, groupTb );
createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
createTool( SMESHOp::OpConstructGroup, groupTb );
createTool( SMESHOp::OpEditGroup, groupTb );
- int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
+ 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" ) ) ;
+ 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" ) ) ;
+ 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" ) ) ;
+ 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" ) ) ;
+ 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" ) ) ;
+ 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" ) ) ;
+ int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
createTool( SMESHOp::OpRemoveNodes, remTb );
createTool( SMESHOp::OpRemoveElements, remTb );
createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
//createTool( SMESHOp::OpRenumberingNodes, renumbTb );
//createTool( SMESHOp::OpRenumberingElements, renumbTb );
- int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
+ 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" ) ) ;
+ 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
- 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 );
+#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" ) ) ;
+ int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
createTool( SMESHOp::OpMinimumDistance, measuremTb );
- int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
+ int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
createTool( SMESHOp::OpUpdate, dispModeTb );
QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
- createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && " + isNotEmpty );
+ 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" );
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
- 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 );
+ popupMgr()->insert( separator(), -1, 0 );
+#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
QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
#ifdef WITH_CGNS
createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
#endif
- 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::OpExportMESHIO, OB, mesh_group, only_one_non_empty, anId );
anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
#ifdef WITH_CGNS
createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
#endif
- createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
popupMgr()->insert( separator(), -1, 0 );
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 );
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 )
{
bool res = SalomeApp_Module::activateModule( 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("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( exportgroup, "columns", 2 );
addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
+ addPreference( tr( "PREF_MED_SAVE_NUMS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "med_save_numbers" );
int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
setPreferenceProperty( zTol, "precision", 10 );
setPreferenceProperty( zTol, "min", 0.0000000001 );
int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
/* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
- LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
- double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
- LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
- double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
- LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
- int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
- LightApp_Preferences::IntSpin, "SMESH", "element_width");
- int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
- LightApp_Preferences::IntSpin, "SMESH", "outline_width");
- int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
- LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
+ LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
+ int ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
+ LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
+ int ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
+ LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
+ int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
+ LightApp_Preferences::IntSpin, "SMESH", "element_width");
+ int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
+ LightApp_Preferences::IntSpin, "SMESH", "outline_width");
+ int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
+ LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
setPreferenceProperty( size0d, "min", 1 );
setPreferenceProperty( size0d, "max", 10 );
- // setPreferenceProperty( ballSize, "min", 1 );
- // setPreferenceProperty( ballSize, "max", 10 );
+ // setPreferenceProperty( ballSize, "min", 1 );
+ // setPreferenceProperty( ballSize, "max", 10 );
setPreferenceProperty( ballDiameter, "min", 1e-7 );
setPreferenceProperty( ballDiameter, "max", 1e9 );
addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
// Adaptation - begin
+#ifndef DISABLE_MG_ADAPT
// 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 );
aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
setPreferenceProperty( pref, "strings", aListOfTimeStep );
+#endif
// Adaptation - end
-
}
void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
{
if ( sect=="SMESH" ) {
- float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
- float aTol = 1.00000009999999;
+ double sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
+ double aTol = 1.00000009999999;
std::string aWarning;
SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
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;
- // 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;
}