-// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// SMESH includes
#include "SMESHGUI.h"
-#include "SMESHGUI_AdaptDlg.h"
#include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
#include "SMESHGUI_AddMeshElementDlg.h"
#include "SMESHGUI_AddQuadraticElementDlg.h"
#include "SMESHGUI_GroupUtils.h"
#include "SMESHGUI_Hypotheses.h"
#include "SMESHGUI_HypothesesUtils.h"
+#include "SMESHGUI_MG_ADAPTDRIVER.h"
#include "SMESHGUI_Make2DFrom3DOp.h"
#include "SMESHGUI_MakeNodeAtPointDlg.h"
#include "SMESHGUI_Measurements.h"
#include "SMESH_ControlsDef.hxx"
#include "SMESH_ScalarBarActor.h"
#include "SMESH_TypeFilter.hxx"
+#include "SMESH_Component_Generator.hxx"
// SALOME GUI includes
#include <LightApp_DataOwner.h>
#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 <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
}
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 ]);
aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
}
}
- 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));
+ 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
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
wc.resume();
}
}
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];
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() );
*
*/
//=============================================================================
-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);
+ SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
+ if( dynamic_cast<SALOME_NamingService *>(ns) )
+ myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
+ else
+ {
+ Engines::EngineComponent_var comp = RetrieveSMESHInstance();
+ myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
+ }
+
//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] +
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:
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
// Adaptation - end
case SMESHOp::OpSplitBiQuadratic:
case SMESHOp::OpConvertMeshToQuadratic:
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();
{
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();
{
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;
}
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
// Adaptation - end
createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
+#ifndef DISABLE_MG_ADAPT
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 );
//createMenu( SMESHOp::OpImportDAT, importId, -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
// 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::OpVolume, ctrl3dTb );
createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
createTool( SMESHOp::OpEqualVolume, 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::OpExtrusion, 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 );
+#ifndef DISABLE_MG_ADAPT
+ int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
+ createTool( SMESHOp::OpMGAdapt, 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 );
+#ifndef DISABLE_MG_ADAPT
+ popupMgr()->insert( separator(), -1, 0 );
+ createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
+ popupMgr()->insert( separator(), -1, 0 );
+#endif
// Adaptation - end
QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
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("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 ) {
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::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;
}
