-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2014 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
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include <GEOMBase.h>
#include <GeometryGUI.h>
#include <GEOM_wrap.hxx>
+#include <GEOMImpl_Types.hxx>
// SALOME GUI includes
#include <SalomeApp_Tools.h>
// Qt includes
#include <QStringList>
#include <QLineEdit>
+#include <QApplication>
// OCCT includes
#include <TopoDS.hxx>
connect( myDlg, SIGNAL( hypoSet( const QString& )), SLOT( onHypoSet( const QString& )));
connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool )));
connect( myDlg, SIGNAL( selectMeshType( const int, const int ) ), SLOT( onAlgoSetByMeshType( const int, const int)));
- if ( myToCreate )
+ if ( myToCreate ) {
if ( myIsMesh ) myHelpFileName = "constructing_meshes_page.html";
- else myHelpFileName = "constructing_submeshes_page.html";
- else myHelpFileName = "editing_meshes_page.html";
+ else myHelpFileName = "constructing_submeshes_page.html";
+ }
+ else {
+ myHelpFileName = "editing_meshes_page.html";
+ }
}
SMESHGUI_SelectionOp::startOperation();
// iterate through dimensions and get available algoritms, set them to the dialog
selectionDone();
myIgnoreAlgoSelection = false;
+ myHasConcurrentSubBefore = false;
myObjectToSelect.clear();
}
}
myDlg->setMaxHypoDim( shapeDim );
myMaxShapeDim = shapeDim;
- myDlg->setHypoSets( SMESH::GetHypothesesSets( shapeDim, "" ));
+ myDlg->setHypoSets( SMESH::GetHypothesesSets( shapeDim ));
if (!myToCreate) // edition: read hypotheses
{
if (pObj != 0)
{
- SMESH::SMESH_subMesh_var aVar =
+ SMESH::SMESH_subMesh_var submeshVar =
SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() );
- myDlg->setObjectShown( SMESHGUI_MeshDlg::Mesh, !aVar->_is_nil() );
+ myDlg->setObjectShown( SMESHGUI_MeshDlg::Mesh, !submeshVar->_is_nil() );
myDlg->setObjectShown( SMESHGUI_MeshDlg::Geom, true );
myDlg->objectWg( SMESHGUI_MeshDlg::Mesh, SMESHGUI_MeshDlg::Btn )->hide();
myDlg->objectWg( SMESHGUI_MeshDlg::Geom, SMESHGUI_MeshDlg::Btn )->hide();
myDlg->updateGeometry();
myDlg->adjustSize();
readMesh();
+ myIsMesh = submeshVar->_is_nil();
}
else
myDlg->reset();
myDlg->disableTab(i);
}
myMaxShapeDim = -1;
- //Hide labels and fields (Mesh ang Geometry)
+ //Hide labels and fields (Mesh and Geometry)
myDlg->setObjectShown( SMESHGUI_MeshDlg::Mesh, false );
myDlg->setObjectShown( SMESHGUI_MeshDlg::Geom, false );
myDlg->adjustSize();
readMesh();
}
+ int curIndex = myDlg->currentMeshType( );
QStringList TypeMeshList;
createMeshTypeList( TypeMeshList );
setAvailableMeshType( TypeMeshList );
+ curIndex =( curIndex >= TypeMeshList.count() ) ? 0 : curIndex;
+ myDlg->setCurrentMeshType( curIndex );
+ setFilteredAlgoData( myMaxShapeDim, curIndex);
}
catch ( const SALOME::SALOME_Exception& S_ex )
{
if ( myToCreate )
{
QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- if ( aGeomEntry == "" )
+ if ( aGeomEntry.isEmpty() )
{
- theMess = tr( "GEOMETRY_OBJECT_IS_NOT_DEFINED" );
+ theMess = tr( myIsMesh ?
+ "GEOMETRY_OBJECT_IS_NOT_DEFINED_MESH" :
+ "GEOMETRY_OBJECT_IS_NOT_DEFINED_SUBMESH");
+ if ( !myIsMesh )
+ return false;
dlg()->show();
if ( SUIT_MessageBox::warning( myDlg, tr( "SMESH_WRN_WARNING" ), theMess,
SUIT_MessageBox::Yes, SUIT_MessageBox::No ) == SUIT_MessageBox::No )
theHyps.clear();
bool isAlgo = ( theHypType == Algo );
bool isAux = ( theHypType == AddHyp );
- QStringList aHypTypeNameList = SMESH::GetAvailableHypotheses( isAlgo, theDim, isAux, myIsOnGeometry );
+ QStringList aHypTypeNameList = SMESH::GetAvailableHypotheses( isAlgo, theDim, isAux, myIsOnGeometry, !myIsMesh );
QStringList::const_iterator anIter;
for ( anIter = aHypTypeNameList.begin(); anIter != aHypTypeNameList.end(); ++anIter )
//================================================================================
/*!
* \brief Gets existing hypotheses or algorithms
- * \param theDim - specifies dimension of returned hypotheses/algorifms
- * \param theHypType - specifies whether algorims or hypotheses or additional ones
- * are retrieved (possible values are in HypType enumeration)
- * \param theFather - start object for finding ( may be component, mesh, or sub-mesh )
- * \param theHyps - output list of names.
- * \param theHypVars - output list of variables.
- * \param theAlgoData - to select hypos able to be used by this algo (optional)
+ * \param theDim - specifies dimension of returned hypotheses/algorifms
+ * \param theHypType - specifies whether algorims or hypotheses or additional ones
+ * are retrieved (possible values are in HypType enumeration)
+ * \param theFather - start object for finding ( may be component, mesh, or sub-mesh )
+ * \param theHyps - output list of names.
+ * \param theHypVars - output list of variables.
+ * \param theAlgoData - to select hypos able to be used by this algo (optional)
*
* Gets existing (i.e. already created) hypotheses or algorithm in accordance with
* input parameters
*/
//================================================================================
-void SMESHGUI_MeshOp::existingHyps( const int theDim,
- const int theHypType,
- _PTR(SObject) theFather,
- QStringList& theHyps,
- THypList& theHypList,
+void SMESHGUI_MeshOp::existingHyps( const int theDim,
+ const int theHypType,
+ _PTR(SObject) theFather,
+ QStringList& theHyps,
+ THypList& theHypList,
HypothesisData* theAlgoData)
{
// Clear hypoheses list
if ( !aData) continue;
if ( ( theDim == -1 || aData->Dim.contains( theDim ) ) &&
( isCompatible ( theAlgoData, aData, theHypType )) &&
- ( isAux == aData->IsAux ))
+ ( theHypType == Algo || isAux == aData->IsAuxOrNeedHyp ))
{
std::string aHypName = aName->Value();
theHyps.append( aHypName.c_str() );
const bool isSubmesh = ( myToCreate ? !myIsMesh : myDlg->isObjectShown( SMESHGUI_MeshDlg::Mesh ));
+ // if ( aDim >= SMESH::DIM_2D ) myAvailableHypData[ aDim ][ Algo ] = myFilteredAlgoData[aDim];
HypothesisData* algoData = hypData( aDim, Algo, theIndex );
HypothesisData* algoByDim[4];
algoByDim[ aDim ] = algoData;
QStringList anAvailable;
- if ( !algoData ) { // all algos becomes available
- availableHyps( aDim, Algo, anAvailable, myAvailableHypData[ aDim ][ Algo ]);
- myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable );
- }
- // check that tab enable, if algorithm building needed algo is one less than dimension
- if ( algoData && myIsOnGeometry && !algoData->InputTypes.isEmpty() &&
- ( aDim > SMESH::DIM_0D ) && !isAccessibleDim( aDim - 1 ) ){
- myDlg->enableTab( aDim - 1 );
- }
- if ( (myDlg->currentMeshType() != MT_ANY) &&
- (( !algoData && ( aDim > SMESH::DIM_0D ) && isAccessibleDim( aDim - 1 )) ||
- ( algoData && myIsOnGeometry && algoData->InputTypes.isEmpty() &&
- ( aDim > SMESH::DIM_0D ) && isAccessibleDim( aDim - 1 ) ) ) ){
- for (int i = aDim - 1; i >= SMESH::DIM_0D; i--){
- if ( isAccessibleDim( i ) ) myDlg->disableTab( i );
+
+ // check that tab enabled of one less dimension
+ if ( aDim > SMESH::DIM_0D )
+ {
+ if ( isAccessibleDim( aDim - 1 ) )
+ {
+ if (( myDlg->currentMeshType() != MT_ANY ) &&
+ ( !algoData || ( myIsOnGeometry && algoData->InputTypes.isEmpty() )))
+ for (int i = aDim - 1; i >= SMESH::DIM_0D; i--)
+ if ( isAccessibleDim( i ) ) {
+ myDlg->disableTab( i );
+ setCurrentHyp(i, Algo, -1);
+ }
+ }
+ else if ( algoData && myIsOnGeometry && !algoData->InputTypes.isEmpty() )
+ {
+ myDlg->enableTab( aDim - 1 );
}
}
+
// check that algorithms of other dimentions are compatible with
// the selected one
-
- // 2 loops: backward and forward from algo dimension
+ if ( !algoData ) { // all algos becomes available
+ if (myDlg->currentMeshType() == MT_ANY || aDim == SMESH::DIM_1D || aDim == SMESH::DIM_0D)
+ availableHyps( aDim, Algo, anAvailable, myAvailableHypData[ aDim ][ Algo ]);
+ else{
+ anAvailable.clear();
+ for (int i = 0; i < myFilteredAlgoData[aDim].count(); ++i) {
+ HypothesisData* aCurAlgo = myFilteredAlgoData[aDim][ i ];
+ anAvailable.append( aCurAlgo->Label );
+ }
+ }
+ myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable );
+ }
+ // 2 loops: backward and forward from algo dimension
for ( int forward = false; forward <= true; ++forward )
{
int dim = aDim + 1, lastDim = SMESH::DIM_3D, dir = 1;
curAlgo = 0;
}
// set new available algoritms
- availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], prevAlgo );
+ if (myDlg->currentMeshType() == MT_ANY || dim == SMESH::DIM_1D || dim == SMESH::DIM_0D)
+ availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], prevAlgo );
+ else{
+ anAvailable.clear();
+ myAvailableHypData[dim][Algo].clear();
+ for (int i = 0; i < myFilteredAlgoData[dim].count(); ++i) {
+ HypothesisData* aCurAlgo = myFilteredAlgoData[dim][ i ];
+ if ( isCompatible ( prevAlgo, aCurAlgo, Algo )) {
+ anAvailable.append( aCurAlgo->Label );
+ myAvailableHypData[dim][Algo].append( aCurAlgo );
+ }
+ }
+ }
HypothesisData* soleCompatible = 0;
if ( anAvailable.count() == 1 )
soleCompatible = myAvailableHypData[dim][Algo][0];
- if ( dim == aTopDim && prevAlgo ) // all available algoritms should be selectable any way
- availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], 0 );
+ if ( dim == aTopDim && prevAlgo ) {// all available algoritms should be selectable any way
+ if (myDlg->currentMeshType() == MT_ANY)
+ availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], 0 );
+ }
myDlg->tab( dim )->setAvailableHyps( Algo, anAvailable );
noCompatible = anAvailable.isEmpty();
if ( !isSubmesh && algoIndex < 0 && soleCompatible && !forward && dim != SMESH::DIM_0D)
// select the sole compatible algo
algoIndex = myAvailableHypData[dim][Algo].indexOf( soleCompatible );
- setCurrentHyp( dim, Algo, algoIndex );
+ setCurrentHyp( dim, Algo, algoIndex);
// remember current algo
prevAlgo = algoByDim[ dim ] = hypData( dim, Algo, algoIndex );
bool algoDeselectedByUser = ( theDim < 0 && aDim == dim );
CORBA::String_var curHypType = curHyp->GetName();
if ( !algoDeselectedByUser &&
- myObjHyps[ dim ][ type ].count() > 0 &&
- !strcmp( curHypType, myObjHyps[ dim ][ type ].first().first->GetName()) )
+ myObjHyps[ dim ][ type ].count() > 0 &&
+ !strcmp( curHypType, myObjHyps[ dim ][ type ].first().first->GetName()) )
{
HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() );
for (int i = 0; i < myAvailableHypData[ dim ][ Algo ].count(); ++i) {
}
}
// get hyps compatible with curAlgo
+ bool defaulHypAvlbl = false;
if ( curAlgo )
{
// check if a selected hyp is compatible with the curAlgo
}
existingHyps( dim, type, pObj, anExisting, myExistingHyps[ dim ][ type ], curAlgo);
availableHyps( dim, type, anAvailable, myAvailableHypData[ dim ][ type ], curAlgo);
+ defaulHypAvlbl = (type == MainHyp && !curAlgo->IsAuxOrNeedHyp );
}
// set list of hypotheses
myDlg->tab( dim )->setAvailableHyps( type, anAvailable );
- myDlg->tab( dim )->setExistingHyps( type, anExisting );
+ myDlg->tab( dim )->setExistingHyps( type, anExisting, defaulHypAvlbl );
// set current existing hypothesis
if ( !curHyp->_is_nil() && !anExisting.isEmpty() )
CORBA::String_var hypTypeName = myExistingHyps[ dim ][ type ].first().first->GetName();
bool isOptional = true;
if ( algoByDim[ dim ] &&
- SMESH::IsAvailableHypothesis( algoByDim[ dim ], hypTypeName.in(), isOptional ) &&
- !isOptional )
+ SMESH::IsAvailableHypothesis( algoByDim[ dim ], hypTypeName.in(), isOptional ) &&
+ !isOptional )
hypIndex = 0;
}
setCurrentHyp( dim, type, hypIndex );
{
theMess = "";
- //QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- //QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
-
QStringList aList;
myDlg->selectedObject( SMESHGUI_MeshDlg::Geom, aList );
if ( aList.isEmpty() )
}
return true;
}
+ QString namePrefix;
+ if ( aList.count() > 1 )
+ {
+ namePrefix = myDlg->objectText( SMESHGUI_MeshDlg::Obj );
+ int i = namePrefix.length() - 1;
+ while ( i > 0 && namePrefix[i].isDigit() )
+ --i;
+ if ( i < namePrefix.length() - 1 )
+ namePrefix.chop( namePrefix.length() - 1 - i );
+ else
+ namePrefix += "_";
+ }
QStringList::Iterator it = aList.begin();
- for ( ; it!=aList.end(); it++)
+ for ( int i = 0; it!=aList.end(); it++, ++i )
{
QString aGeomEntry = *it;
_PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() );
return false;
_PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar.in() );
if ( aMeshSO ) {
- SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ) );
theEntryList.append( aMeshSO->GetID().c_str() );
+ if ( i > 0 ) setDefaultName( namePrefix );
+ SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ) );
}
for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ ) {
selectObject( _PTR(SObject)() );
selectionDone();
+ checkSubMeshConcurrency( aMeshVar, aSubMeshVar, /*askUser=*/true );
+
return true;
}
* Generates and sets default mesh/submesh name(Mesh_1, Mesh_2, etc.)
*/
//================================================================================
-void SMESHGUI_MeshOp::setDefaultName() const
+void SMESHGUI_MeshOp::setDefaultName( const QString& thePrefix ) const
{
QString aResName;
_PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
int i = 1;
- QString aPrefix = tr( myIsMesh ? "SMESH_OBJECT_MESH" : "SMESH_SUBMESH" ) + "_";
+
+ QString aPrefix = thePrefix;
+ if ( aPrefix.isEmpty() )
+ aPrefix = tr( myIsMesh ? "SMESH_OBJECT_MESH" : "SMESH_SUBMESH" ) + "_";
+
_PTR(SObject) anObj;
do
{
//================================================================================
/*!
- * \brief Reads parameters of an edited mesh and assigns them to the dialog
+ * \brief Reads parameters of an edited mesh/sub-mesh and assigns them to the dialog
*
* Called when mesh is edited only.
*/
QString aMeshName = name( aMeshSO );
myDlg->setObjectText( SMESHGUI_MeshDlg::Mesh, aMeshName );
}
+ myHasConcurrentSubBefore = checkSubMeshConcurrency( aMeshVar, aSubMeshVar );
}
// Get name of geometry object
// Get hypotheses and algorithms assigned to the mesh/sub-mesh
QStringList anExisting;
const int lastDim = ( myIsOnGeometry ) ? SMESH::DIM_0D : SMESH::DIM_3D;
+ bool algoFound = false;
for ( int dim = SMESH::DIM_3D; dim >= lastDim; --dim )
{
// get algorithm
// myAvailableHypData[ dim ][ Algo ].push_back( algoData );
// aHypIndex = myAvailableHypData[ dim ][ hypType ].count() - 1;
// }
+ algoFound = ( aHypIndex > -1 );
}
setCurrentHyp( dim, Algo, aHypIndex );
// set existing and available hypothesis according to the selected algo
- onAlgoSelected( aHypIndex, dim );
+ if ( aHypIndex > -1 || !algoFound )
+ onAlgoSelected( aHypIndex, dim );
}
// get hypotheses
}
}
+ SALOMEDS_SObject* aSObject = _CAST(SObject, pObj);
+ CORBA::Object_var anObject = aSObject->GetObject();
+ SMESH::SMESH_Mesh_var aMeshVar = SMESH::SMESH_Mesh::_narrow( anObject );
+ SMESH::SMESH_subMesh_var aSubMeshVar = SMESH::SMESH_subMesh::_narrow( anObject );
+ bool isMesh = !aMeshVar->_is_nil();
+ if ( !isMesh && !aSubMeshVar->_is_nil() )
+ aMeshVar = aSubMeshVar->GetFather();
+
// Assign new algorithms and hypotheses
for ( int dim = aDim; dim <= SMESH::DIM_3D; dim++ )
{
if ( !anAlgoVar->_is_nil() && // some algo selected and
myObjHyps[ dim ][ Algo ].count() == 0 ) // no algo assigned
{
- SALOMEDS_SObject* aSObject = _CAST(SObject, pObj);
- CORBA::Object_var anObject = aSObject->GetObject();
- SMESH::SMESH_Mesh_var aMeshVar = SMESH::SMESH_Mesh::_narrow( anObject );
- bool isMesh = !aMeshVar->_is_nil();
- if ( isMesh ) {
+ if ( isMesh )
SMESH::AddHypothesisOnMesh( aMeshVar, anAlgoVar );
- } else {
- SMESH::SMESH_subMesh_var aVar =
- SMESH::SMESH_subMesh::_narrow( _CAST(SObject,pObj)->GetObject() );
- if ( !aVar->_is_nil() )
- SMESH::AddHypothesisOnSubMesh( aVar, anAlgoVar );
- }
+ else if ( !aSubMeshVar->_is_nil() )
+ SMESH::AddHypothesisOnSubMesh( aSubMeshVar, anAlgoVar );
+
myObjHyps[ dim ][ Algo ].append( THypItem( anAlgoVar, aName) );
}
}
// assign new hypotheses
- if ( aNewHypIndex != anOldHypIndex && aNewHypIndex != -1 )
+ if ( aNewHypIndex != anOldHypIndex && aNewHypIndex > -1 )
{
- SMESH::SMESH_Mesh_var aMeshVar =
- SMESH::SMESH_Mesh::_narrow( _CAST(SObject,pObj)->GetObject() );
- bool isMesh = !aMeshVar->_is_nil();
if ( isMesh )
- {
SMESH::AddHypothesisOnMesh
(aMeshVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
- }
- else
- {
- SMESH::SMESH_subMesh_var aVar =
- SMESH::SMESH_subMesh::_narrow( _CAST(SObject,pObj)->GetObject() );
- if ( !aVar->_is_nil() )
- SMESH::AddHypothesisOnSubMesh
- ( aVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
- }
+ else if ( !aSubMeshVar->_is_nil() )
+ SMESH::AddHypothesisOnSubMesh
+ ( aSubMeshVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
}
// reread all hypotheses of mesh if necessary
QStringList anExisting;
}
}
+ myHasConcurrentSubBefore =
+ checkSubMeshConcurrency( aMeshVar, aSubMeshVar, /*askUser=*/!myHasConcurrentSubBefore );
+
return true;
}
+//================================================================================
+/*!
+ * \brief Checks if a concurrent sub-meshes appear as result of sub-mesh
+ * creation/edition and, if (askUser) , proposes the uses to set up a desired
+ * order of sub-mesh computation.
+ * Returns \c true if a sub-mesh concurrency detected.
+ */
+//================================================================================
+
+bool SMESHGUI_MeshOp::checkSubMeshConcurrency(SMESH::SMESH_Mesh_ptr mesh,
+ SMESH::SMESH_subMesh_ptr submesh,
+ bool askUser)
+{
+ if ( CORBA::is_nil( mesh ) || CORBA::is_nil( submesh ))
+ return false;
+
+ bool isNewConcurrent = mesh->IsUnorderedSubMesh( submesh->GetId() );
+ if ( isNewConcurrent && askUser )
+ {
+ int butID = SUIT_MessageBox::warning( myDlg->parentWidget(), tr( "SMESH_WARNING" ),
+ tr("CONCURRENT_SUBMESH_APPEARS"),
+ tr("SMESH_BUT_YES"), tr("SMESH_BUT_NO"));
+ if ( butID == 0 )
+ {
+ _PTR(SObject) meshSO = SMESH::FindSObject( mesh );
+ LightApp_SelectionMgr* aSelectionMgr = selectionMgr();
+ if ( meshSO && aSelectionMgr )
+ {
+ myDlg->setEnabled( false ); // disactivate selection
+ selectionMgr()->clearFilters();
+ selectObject( meshSO );
+ SMESHGUI::GetSMESHGUI()->OnGUIEvent( 713 ); // MESH_ORDER
+ qApp->processEvents();
+
+ myDlg->setEnabled( true );
+ int obj = myDlg->getActiveObject();
+ onActivateObject( obj ); // restore filter
+ if ( !myToCreate )
+ {
+ selectObject( SMESH::FindSObject( submesh ));
+ selectionDone();
+ }
+ }
+ }
+ }
+
+ return isNewConcurrent;
+}
+
//================================================================================
/*!
* \brief Verifies whether given operator is valid for this one
{
theTypeMesh.clear();
theTypeMesh.append( tr( "MT_ANY" ) );
- if ( myIsOnGeometry && ( myMaxShapeDim >= 2 || myMaxShapeDim == -1 ) )
+ if ( myMaxShapeDim >= 2 || myMaxShapeDim == -1 )
{
theTypeMesh.append( tr( "MT_TRIANGULAR" ) );
theTypeMesh.append( tr( "MT_QUADRILATERAL" ) );
}
- if ( myIsOnGeometry && ( myMaxShapeDim == 3 || myMaxShapeDim == -1 ) )
+ if ( myMaxShapeDim == 3 || myMaxShapeDim == -1 )
{
theTypeMesh.append( tr( "MT_TETRAHEDRAL" ) );
theTypeMesh.append( tr( "MT_HEXAHEDRAL" ) );
*/
//================================================================================
void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex)
+{
+ setFilteredAlgoData( theTabIndex, theIndex);
+}
+
+//================================================================================
+/*!
+ * \brief Set a filtered list of available algorithms by mesh type
+ * \param theTabIndex - Index of current active tab
+ * \param theIndex - Index of current type of mesh
+ */
+//================================================================================
+void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theIndex)
{
int aDim;
- if ( !myIsOnGeometry ) return;
THypDataList anAvailableAlgsData;
QStringList anAvailableAlgs;
- QString anCompareType = "ANY";
+ QString anCompareType = "";
bool isAvailableChoiceAlgo = false;
int anCurrentAvailableAlgo = 0;
bool isNone = true;
switch ( theIndex ) {
- case MT_ANY:
+ case MT_ANY:
+ anCompareType = "ANY";
+ aDim = SMESH::DIM_3D;
+ break;
+ case MT_TRIANGULAR:
+ aDim = SMESH::DIM_2D;
+ anCompareType = "TRIA";
+ break;
+ case MT_QUADRILATERAL:
+ aDim = SMESH::DIM_2D;
+ anCompareType = "QUAD";
+ break;
+ case MT_TETRAHEDRAL:
+ aDim = SMESH::DIM_3D;
+ anCompareType = "TETRA";
+ break;
+ case MT_HEXAHEDRAL:
+ aDim = SMESH::DIM_3D;
+ anCompareType = "HEXA";
+ break;
+ default:;
+ }
+
+ bool toCheckIsApplicableToAll = !myIsMesh;
+ GEOM::GEOM_Object_var aGeomVar;
+ QString anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
+ if ( _PTR(SObject) so = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
+ {
+ CORBA::Object_var obj = _CAST( SObject,so )->GetObject();
+ aGeomVar = GEOM::GEOM_Object::_narrow( obj );
+ if ( !aGeomVar->_is_nil() && toCheckIsApplicableToAll )
+ toCheckIsApplicableToAll = ( aGeomVar->GetType() == GEOM_GROUP );
+ }
+
+ if ( anCompareType == "ANY" )
+ {
+ for ( int dim = SMESH::DIM_2D; dim <= SMESH::DIM_3D; dim++ )
{
- for ( int dim = SMESH::DIM_2D; dim <= SMESH::DIM_3D; dim++ )
+ isNone = currentHyp( dim, Algo ) < 0;
+ isAvailableChoiceAlgo = false;
+ // retrieves a list of available algorithms from resources
+ availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData );
+ //return current algo in current tab and set new algorithm list
+ HypothesisData* algoCur;
+ if ( !isNone && !myAvailableHypData[dim][Algo].empty() ) {
+ algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) );
+ }
+ myAvailableHypData[dim][Algo].clear();
+ anAvailableAlgs.clear();
+ for (int i = 0 ; i < anAvailableAlgsData.count(); i++)
{
- isNone = currentHyp( dim, Algo ) < 0;
- isAvailableChoiceAlgo = false;
- // retrieves a list of available algorithms from resources
- availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData );
- //return current algo in current tab
- if ( !isNone && !myAvailableHypData[dim][Algo].empty() ){
- for (int i = 0 ; i < anAvailableAlgsData.count(); i++)
- {
- HypothesisData* algoAny = anAvailableAlgsData.at(i);
- HypothesisData* algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) );
- QString tem = algoAny->Label;
- if ( algoAny->Label == algoCur->Label ){
- isAvailableChoiceAlgo = true;
- anCurrentAvailableAlgo = i;
- break;
- }
- }
+ HypothesisData* curAlgo = anAvailableAlgsData.at(i);
+ if ( aGeomVar->_is_nil() ||
+ SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, toCheckIsApplicableToAll ))
+ {
+ anAvailableAlgs.append( curAlgo->Label );
+ myAvailableHypData[dim][Algo].append( curAlgo );
}
- else if ( !isNone ){
- isAvailableChoiceAlgo = true;
- anCurrentAvailableAlgo = currentHyp( dim, Algo );
+ }
+ if ( !isNone && algoCur ) {
+ for (int i = 0 ; i < myAvailableHypData[dim][Algo].count(); i++)
+ {
+ HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i);
+ if ( algoAny->Label == algoCur->Label ){
+ isAvailableChoiceAlgo = true;
+ anCurrentAvailableAlgo = i;
+ break;
+ }
}
- //set new algorithm list and select the current algorithm
- myAvailableHypData[dim][Algo] = anAvailableAlgsData;
- myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
- if ( isAvailableChoiceAlgo )
- setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
}
- int aMaxShapeDim = ( myMaxShapeDim == -1 ) ? SMESH::DIM_3D : myMaxShapeDim;
- for ( int i = SMESH::DIM_0D; i <= aMaxShapeDim; i++ ) {
- myDlg->enableTab( i );
+ else if ( !isNone ) {
+ isAvailableChoiceAlgo = true;
+ anCurrentAvailableAlgo = currentHyp( dim, Algo );
}
- myDlg->setCurrentTab( theTabIndex );
- myDlg->setHypoSets( SMESH::GetHypothesesSets( aMaxShapeDim, "" ) );
+ myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
+ if ( isAvailableChoiceAlgo )
+ setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
}
- break;
- case MT_TRIANGULAR:{
- aDim = SMESH::DIM_2D;
- anCompareType = "TRIA";
- }
- break;
- case MT_QUADRILATERAL:{
- aDim = SMESH::DIM_2D;
- anCompareType = "QUAD";
- }
- break;
- case MT_TETRAHEDRAL:{
- aDim = SMESH::DIM_3D;
- anCompareType = "TETRA";
- }
- break;
- case MT_HEXAHEDRAL:{
- aDim = SMESH::DIM_3D;
- anCompareType = "HEXA";
- }
- break;
- default:;
+ if ( !myIsOnGeometry )
+ for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
+ if ( i < SMESH::DIM_3D ) myDlg->disableTab( i );
+ else myDlg->enableTab( i );
+ }
+ else
+ for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
+ if ( i > myMaxShapeDim ) myDlg->disableTab( i );
+ else myDlg->enableTab( i );
+ }
+ myDlg->setCurrentTab( theTabIndex );
}
- if ( anCompareType != "ANY" )
+ else
{
QString anCurrentAlgo;
bool isReqDisBound = true;
+ QString anCurrentCompareType = anCompareType;
isNone = currentHyp( aDim, Algo ) < 0;
- // retrieves a list of available algorithms from resources
- availableHyps( aDim, Algo, anAvailableAlgs, anAvailableAlgsData );
- // finding algorithm which is selected
if ( !isNone && !myAvailableHypData[aDim][Algo].empty() &&
- myAvailableHypData[aDim][Algo].count() != anAvailableAlgsData.count() ){
- anCurrentAlgo = myAvailableHypData[aDim][Algo].at( currentHyp( aDim, Algo ) )->Label;
+ myAvailableHypData[aDim][Algo].count() != anAvailableAlgsData.count() )
isReqDisBound = myAvailableHypData[aDim][Algo].at( currentHyp( aDim, Algo ) )->InputTypes.isEmpty();
- }
- else if ( !isNone ){
- anCurrentAlgo = anAvailableAlgsData.at( currentHyp( aDim, Algo ) )->Label;
+ else if ( !isNone )
isReqDisBound = anAvailableAlgsData.at( currentHyp( aDim, Algo ) )->InputTypes.isEmpty();
- }
- anAvailableAlgs.clear();
- myAvailableHypData[aDim][Algo].clear();
- // finding and adding algorithm depending on the type mesh
- for ( int i = 0 ; i < anAvailableAlgsData.count(); i++ )
+ for ( int dim = aDim; dim >= SMESH::DIM_2D; dim-- )
{
- HypothesisData* algoIn = anAvailableAlgsData.at( i );
- bool isAvailableAlgo = ( algoIn->OutputTypes.count() == 0 );
- QStringList::const_iterator inElemType = algoIn->OutputTypes.begin();
- for ( ; inElemType != algoIn->OutputTypes.end(); inElemType++ )
+ bool isNoneAlg = currentHyp( dim, Algo ) < 0;
+ isAvailableChoiceAlgo = false;
+ // retrieves a list of available algorithms from resources
+ availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData );
+ // finding algorithm which is selected
+ if ( !isNoneAlg && !myAvailableHypData[dim][Algo].empty() &&
+ myAvailableHypData[dim][Algo].count() != anAvailableAlgsData.count() )
+ anCurrentAlgo = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) )->Label;
+ else if ( !isNoneAlg )
+ anCurrentAlgo = anAvailableAlgsData.at( currentHyp( dim, Algo ) )->Label;
+ anAvailableAlgs.clear();
+ myAvailableHypData[dim][Algo].clear();
+ myFilteredAlgoData[dim].clear();
+ // finding and adding algorithm depending on the type mesh
+ for ( int i = 0 ; i < anAvailableAlgsData.count(); i++ )
{
- if ( *inElemType == anCompareType ){
- isAvailableAlgo = true;
- break;
+ HypothesisData* algoIn = anAvailableAlgsData.at( i );
+ bool isAvailableAlgo = ( algoIn->OutputTypes.count() == 0 );
+ QStringList::const_iterator inElemType = algoIn->OutputTypes.begin();
+ for ( ; inElemType != algoIn->OutputTypes.end(); inElemType++ )
+ {
+ if ( *inElemType == anCurrentCompareType ) {
+ isAvailableAlgo = true;
+ break;
+ }
+ }
+ if ( isAvailableAlgo || algoIn->OutputTypes.count()==0 ) {
+ if ( aGeomVar->_is_nil() || myMaxShapeDim != dim ||
+ SMESH::IsApplicable( algoIn->TypeName, aGeomVar, toCheckIsApplicableToAll ))
+ {
+ anAvailableAlgs.append( algoIn->Label );
+ myAvailableHypData[dim][Algo].append( algoIn );
+ myFilteredAlgoData[dim].append( algoIn );
+ }
+ }
+ //algorithm will be active, if the chosen algorithm available in the current mesh type
+ if ( !isNoneAlg && isAvailableAlgo && algoIn->Label == anCurrentAlgo ) {
+ isAvailableChoiceAlgo = true;
+ anCurrentAvailableAlgo = anAvailableAlgs.count() - 1 ;
}
}
- if ( isAvailableAlgo || algoIn->OutputTypes.count()==0 ){
- anAvailableAlgs.append( algoIn->Label );
- myAvailableHypData[aDim][Algo].append( algoIn );
- }
- //algorithm will be active, if the chosen algorithm available in the current mesh type
- if ( !isNone && isAvailableAlgo && algoIn->Label == anCurrentAlgo ){
- isAvailableChoiceAlgo = true;
- anCurrentAvailableAlgo = anAvailableAlgs.count() - 1 ;
- }
+ //set new algorithm list and select the current algorithm
+ myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
+ anCurrentCompareType = ( anCompareType == "HEXA" ) ? "QUAD" : "TRIA";
+ if ( isAvailableChoiceAlgo )
+ setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
+ else
+ setCurrentHyp( dim, Algo, -1 );
}
- //set new algorithm list and select the current algorithm
- myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailableAlgs );
- if ( isAvailableChoiceAlgo )
- setCurrentHyp( aDim, Algo, anCurrentAvailableAlgo );
- int aMaxShapeDim = ( myMaxShapeDim == -1 ) ? SMESH::DIM_3D : myMaxShapeDim;
- if ( isNone || isReqDisBound || !isAvailableChoiceAlgo ) {
- for ( int i = SMESH::DIM_0D; i <= aMaxShapeDim; i++ ) {
+
+ if ( isNone || isReqDisBound ) {
+ for ( int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++ ) {
if ( aDim != i ) {
myDlg->disableTab( i );
setCurrentHyp(i, Algo, -1);
}
}
}
- else if ( !isNone ){
+ else if ( !isNone ) {
if ( aDim == SMESH::DIM_2D){
myDlg->disableTab( SMESH::DIM_3D );
setCurrentHyp( SMESH::DIM_3D, Algo, -1);
}
for ( int i = aMaxShapeDim; i > SMESH::DIM_0D; i-- )
{
- isReqDisBound = ( currentHyp( i, Algo ) < 0 ) ? true : myAvailableHypData[i][Algo].at( currentHyp( i, Algo ) )->InputTypes.isEmpty();
- if ( aMaxShapeDim != i && isReqDisBound) {
+ isReqDisBound = ( currentHyp( i, Algo ) < 0 ) ? true :
+ myAvailableHypData[i][Algo].at( currentHyp( i, Algo ) )->InputTypes.isEmpty();
+ if ( isReqDisBound ) {
for (int j = i - 1; j >= SMESH::DIM_0D; j--){
myDlg->disableTab( j );
setCurrentHyp( j , Algo, -1 );
}
}
}
- myDlg->setHypoSets( SMESH::GetHypothesesSets( aDim, anCompareType ) );
myDlg->enableTab( aDim );
myDlg->setCurrentTab( aDim );
}
+ QStringList aHypothesesSetsList = SMESH::GetHypothesesSets( aDim );
+ QStringList aFilteredHypothesesSetsList;
+ aFilteredHypothesesSetsList.clear();
+ QStringList::const_iterator inHypoSetName = aHypothesesSetsList.begin();
+ for ( ; inHypoSetName != aHypothesesSetsList.end(); ++inHypoSetName )
+ {
+ HypothesesSet* currentHypoSet = SMESH::GetHypothesesSet( *inHypoSetName );
+ bool isAvailable = false;
+ currentHypoSet->init( true );
+ while ( currentHypoSet->next(), currentHypoSet->more() )
+ {
+ isAvailable = false;
+ if ( HypothesisData* algoDataIn = SMESH::GetHypothesisData( currentHypoSet->current() ))
+ {
+ for (int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++)
+ {
+ for (int j = 0; j < myAvailableHypData[i][Algo].count(); ++j) {
+ HypothesisData* aCurAlgo = hypData( i, Algo, j );
+ if ( aCurAlgo->Label == algoDataIn->Label ){
+ isAvailable = true;
+ break;
+ }
+ }
+ if ( isAvailable ) break;
+ }
+ if ( !isAvailable ) break;
+ }
+ }
+ if ( isAvailable )
+ aFilteredHypothesesSetsList.append( *inHypoSetName );
+ }
+ myDlg->setHypoSets( aFilteredHypothesesSetsList );
}
