-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015 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
#include "SMESHGUI_MeshOp.h"
#include "SMESHGUI.h"
+#include "SMESHGUI_GEOMGenUtils.h"
+#include "SMESHGUI_Hypotheses.h"
+#include "SMESHGUI_HypothesesUtils.h"
#include "SMESHGUI_MeshDlg.h"
+#include "SMESHGUI_Operations.h"
#include "SMESHGUI_ShapeByMeshDlg.h"
-#include "SMESHGUI_HypothesesUtils.h"
-#include "SMESHGUI_Hypotheses.h"
#include "SMESHGUI_Utils.h"
-#include "SMESHGUI_GEOMGenUtils.h"
-
-#include <SMESH_TypeFilter.hxx>
-#include <SMESH_NumberFilter.hxx>
+#include "SMESH_NumberFilter.hxx"
+#include "SMESH_TypeFilter.hxx"
// SALOME GEOM includes
#include <GEOM_SelectionFilter.h>
//================================================================================
SMESHGUI_MeshOp::SMESHGUI_MeshOp( const bool theToCreate, const bool theIsMesh )
: SMESHGUI_SelectionOp(),
- myToCreate( theToCreate ),
- myIsMesh( theIsMesh ),
myDlg( 0 ),
myShapeByMeshOp( 0 ),
+ myToCreate( theToCreate ),
+ myIsMesh( theIsMesh ),
myHypoSet( 0 )
{
if ( GeometryGUI::GetGeomGen()->_is_nil() )// check that GEOM_Gen exists
for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ )
{
connect( myDlg->tab( i ), SIGNAL( createHyp( const int, const int ) ),
- this, SLOT( onCreateHyp( const int, const int ) ) );
+ this, SLOT( onCreateHyp( const int, const int ) ) );
connect( myDlg->tab( i ), SIGNAL( editHyp( const int, const int ) ),
- this, SLOT( onEditHyp( const int, const int ) ) );
+ this, SLOT( onEditHyp( const int, const int ) ) );
connect( myDlg->tab( i ), SIGNAL( selectAlgo( const int ) ),
- this, SLOT( onAlgoSelected( const int ) ) );
+ this, SLOT( onAlgoSelected( const int ) ) );
}
connect( myDlg, SIGNAL( hypoSet( const QString& )), SLOT( onHypoSet( const QString& )));
connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool )));
myDlg->activateObject( myIsMesh ? SMESHGUI_MeshDlg::Geom : SMESHGUI_MeshDlg::Mesh );
}
else
+ {
myDlg->activateObject( SMESHGUI_MeshDlg::Obj );
-
+ }
myDlg->setCurrentTab( SMESH::DIM_3D );
QStringList TypeMeshList;
for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) {
QString aSubGeomEntry = (*aSubShapesIter);
_PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.toLatin1().data());
- GEOM::GEOM_Object_var aSubGeomVar =
- GEOM::GEOM_Object::_narrow(_CAST(SObject,pSubGeom)->GetObject());
- aSeq[iSubSh] = aSubGeomVar;
+
+ if( pSubGeom ) {
+ SALOMEDS_SObject* sobj = _CAST(SObject,pSubGeom);
+ if( sobj ) {
+ GEOM::GEOM_Object_var aSubGeomVar =
+ GEOM::GEOM_Object::_narrow(sobj->GetObject());
+ if( !aSubGeomVar->_is_nil() ){
+ aSeq[iSubSh] = aSubGeomVar;
+ }
+ }
+ }
}
} else {
// get geometry by selected sub-mesh
if (aSeq->length() > 0) {
shapeDim = -1;
- for (int iss = 0; iss < aSeq->length() && shapeDim < 3; iss++) {
+ for ( CORBA::ULong iss = 0; iss < aSeq->length() && shapeDim < 3; iss++) {
GEOM::GEOM_Object_var aGeomVar = aSeq[iss];
switch ( aGeomVar->GetShapeType() ) {
case GEOM::SOLID: shapeDim = 3; break;
{
selectionMgr()->clearFilters();
selectObject( pSubmesh );
- SMESHGUI::GetSMESHGUI()->switchToOperation(704);
+ SMESHGUI::GetSMESHGUI()->switchToOperation( SMESHOp::OpEditMeshOrSubMesh );
return;
}
else
return ( SMESH::IsAvailableHypothesis( theAlgoData, theHypData->TypeName, isOptional ));
}
+//================================================================================
+/*!
+ * \brief check compatibility of the geometry
+ * \param theAlgoData - to select hypos able to be used by this algo
+ * \param theCurrentGeomToSelect - the current name of the selected geometry
+ * \param theGeomVar - currently selected geometry
+ * \retval bool - check result
+ */
+//================================================================================
+bool SMESHGUI_MeshOp::isCompatibleToGeometry(HypothesisData* theAlgoData,
+ QString theCurrentGeomToSelect,
+ GEOM::GEOM_Object_var theGeomVar)
+{
+ if ( theGeomVar->_is_nil() )
+ return true;
+
+ bool isApplicable = false;
+ if ( theCurrentGeomToSelect == myLastGeomToSelect && !theCurrentGeomToSelect.isEmpty() ) {
+ THypLabelIsAppMap::const_iterator iter = myHypMapIsApplicable.find( theAlgoData->Label );
+ if ( iter != myHypMapIsApplicable.end() && iter.key() == theAlgoData->Label ) {
+ isApplicable = iter.value();
+ return isApplicable;
+ }
+ }
+ bool toCheckIsApplicableToAll = !myIsMesh;
+ if ( toCheckIsApplicableToAll )
+ toCheckIsApplicableToAll = ( theGeomVar->GetType() == GEOM_GROUP );
+ isApplicable = SMESH::IsApplicable( theAlgoData->TypeName, theGeomVar, toCheckIsApplicableToAll );
+ myHypMapIsApplicable.insert( theAlgoData->Label, isApplicable );
+ return isApplicable;
+}
+
+//================================================================================
+/*!
+ * \brief check compatibility of the mesh type
+ * \param theAlgoData - to select hypos able to be used by this algo
+ * \param theMeshType - type of mesh for filtering algorithms
+ * \retval bool - check result
+ */
+//================================================================================
+bool SMESHGUI_MeshOp::isCompatibleToMeshType(HypothesisData* theAlgoData,
+ QString theMeshType)
+{
+ bool isAvailableAlgo = ( theAlgoData->OutputTypes.count() == 0 );
+ QStringList::const_iterator inElemType = theAlgoData->OutputTypes.begin();
+ for ( ; inElemType != theAlgoData->OutputTypes.end(); inElemType++ ) {
+ if ( *inElemType == theMeshType ) {
+ isAvailableAlgo = true;
+ break;
+ }
+ }
+ return isAvailableAlgo;
+}
+
//================================================================================
/*!
* \brief Gets available hypotheses or algorithms
* \param theHypType - specifies whether algorims or hypotheses or additional ones
* are retrieved (possible values are in HypType enumeration)
* \param theHyps - Output list of hypotheses' names
- * \param theAlgoData - to select hypos able to be used by this algo (optional)
+ * \param thePrevAlgoData - to select hypos able to be used by previously algo (optional)
+ * \param theNextAlgoData - to select hypos able to be used by next algo (optional)
+ * \param theMeshType - type of mesh for filtering algorithms (optional)
*
* Gets available hypotheses or algorithm in accordance with input parameters
*/
const int theHypType,
QStringList& theHyps,
THypDataList& theDataList,
- HypothesisData* theAlgoData ) const
+ HypothesisData* thePrevAlgoData,
+ HypothesisData* theNextAlgoData,
+ const QString& theMeshType)
{
theDataList.clear();
theHyps.clear();
QStringList aHypTypeNameList = SMESH::GetAvailableHypotheses( isAlgo, theDim, isAux, myIsOnGeometry, !myIsMesh );
QStringList::const_iterator anIter;
+ GEOM::GEOM_Object_var aGeomVar;
+ QString aCurrentGeomToSelect;
+ if ( !theMeshType.isEmpty() ) {
+ aCurrentGeomToSelect = myDlg->selectedObject( myToCreate ? SMESHGUI_MeshDlg::Geom : SMESHGUI_MeshDlg::Obj );
+ if ( _PTR(SObject) so = studyDS()->FindObjectID( aCurrentGeomToSelect.toLatin1().data() )) {
+ aGeomVar = SMESH::GetGeom( so );
+ }
+ if ( aCurrentGeomToSelect != myLastGeomToSelect )
+ myHypMapIsApplicable.clear();
+ }
+
for ( anIter = aHypTypeNameList.begin(); anIter != aHypTypeNameList.end(); ++anIter )
{
HypothesisData* aData = SMESH::GetHypothesisData( *anIter );
- if ( isCompatible ( theAlgoData, aData, theHypType )) {
+ if ( ( isCompatible ( thePrevAlgoData, aData, theHypType ) &&
+ isCompatible ( theNextAlgoData, aData, theHypType ) ) ||
+ ( theMeshType == "ANY" && aData->InputTypes.isEmpty())) {
+ if ( !theMeshType.isEmpty() && theDim >= SMESH::DIM_2D &&
+ ( ( theMeshType != "ANY" && !isCompatibleToMeshType( aData, theMeshType )) ||
+ !isCompatibleToGeometry( aData, aCurrentGeomToSelect, aGeomVar )))
+ continue;
theDataList.append( aData );
theHyps.append( aData->Label );
}
}
+
+ if ( !theMeshType.isEmpty() && !aCurrentGeomToSelect.isEmpty() &&
+ myLastGeomToSelect != aCurrentGeomToSelect )
+ myLastGeomToSelect = aCurrentGeomToSelect;
}
//================================================================================
// 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 ) ) {
+ if ( myIsOnGeometry ) {
+ QString anCompareType = currentMeshTypeName(myDlg->currentMeshType());
+ bool is2dtype = ( anCompareType == "QUAD" ) || ( anCompareType == "TRIA" );
+ int dim = is2dtype ? SMESH::DIM_2D : SMESH::DIM_3D;
+ for (int i = dim; i >= SMESH::DIM_0D; i--) {
+ if ( i != aDim ) {
+ if ( algoData && algoData->InputTypes.isEmpty() ) {
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
- 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 );
+ else {
+ myDlg->enableTab( i );
+ }
+ }
}
}
- myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable );
}
+
+ int algoDim = aDim;
+ HypothesisData* a3DAlgo = 0;
// 2 loops: backward and forward from algo dimension
- for ( int forward = false; forward <= true; ++forward )
+ for ( int forward = 0; forward <= 1; ++forward )
{
- int dim = aDim + 1, lastDim = SMESH::DIM_3D, dir = 1;
+ int dim = algoDim + 1, lastDim = SMESH::DIM_3D, dir = 1;
if ( !forward ) {
- dim = aDim - 1; lastDim = SMESH::DIM_0D; dir = -1;
+ dim = algoDim - 1; lastDim = SMESH::DIM_0D; dir = -1;
}
HypothesisData* prevAlgo = algoData;
bool noCompatible = false;
algoByDim[ dim ] = 0;
continue;
}
+ HypothesisData* nextAlgo = 0;
+ if ( myMaxShapeDim == SMESH::DIM_3D && a3DAlgo && dim == SMESH::DIM_2D ) {
+ nextAlgo = a3DAlgo;
+ }
// get currently selected algo
int algoIndex = currentHyp( dim, Algo );
HypothesisData* curAlgo = hypData( dim, Algo, algoIndex );
- if ( curAlgo ) { // some algo selected
- if ( !isCompatible( prevAlgo, curAlgo, Algo ))
- curAlgo = 0;
+
+ QString anCompareType = currentMeshTypeName(myDlg->currentMeshType());
+ QString anCurrentCompareType = "";
+ if ( dim == SMESH::DIM_3D || anCompareType == "ANY" )
+ anCurrentCompareType = anCompareType;
+ else if ( dim == SMESH::DIM_2D ) {
+ anCurrentCompareType = (anCompareType == "HEXA" || anCompareType == "QUAD") ? "QUAD" : "TRIA";
+ nextAlgo = 0;
}
+
// set new available algoritms
- 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 );
- }
- }
- }
+ availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], prevAlgo, nextAlgo, anCurrentCompareType);
HypothesisData* soleCompatible = 0;
if ( anAvailable.count() == 1 )
soleCompatible = 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();
-
- // restore previously selected algo
algoIndex = myAvailableHypData[dim][Algo].indexOf( curAlgo );
- if ( !isSubmesh && algoIndex < 0 && soleCompatible && !forward && dim != SMESH::DIM_0D)
+ 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);
// remember current algo
prevAlgo = algoByDim[ dim ] = hypData( dim, Algo, algoIndex );
}
+ if ( myMaxShapeDim == SMESH::DIM_3D && forward && algoDim == SMESH::DIM_1D )
+ {
+ algoDim = SMESH::DIM_3D;
+ forward = -1;
+ a3DAlgo = prevAlgo;
+ continue;
+ }
}
// set hypotheses corresponding to the found algoritms
myObjHyps[ dim ][ type ].count() > 0 &&
curHypType == SMESH::toQStr( myObjHyps[ dim ][ type ].first().first->GetName()) )
{
- HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() );
+ HypothesisData* hypData = SMESH::GetHypothesisData( SMESH::toQStr( curHyp->GetName() ));
for (int i = 0; i < myAvailableHypData[ dim ][ Algo ].count(); ++i) {
curAlgo = myAvailableHypData[ dim ][ Algo ][ i ];
if (curAlgo && hypData && isCompatible(curAlgo, hypData, type))
{
// check if a selected hyp is compatible with the curAlgo
if ( !curHyp->_is_nil() ) {
- HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() );
+ HypothesisData* hypData = SMESH::GetHypothesisData( SMESH::toQStr( curHyp->GetName() ));
if ( !isCompatible( curAlgo, hypData, type ))
curHyp = SMESH::SMESH_Hypothesis::_nil();
}
if ( myObjHyps[ dim ][ Algo ].count() > 0 )
{
SMESH::SMESH_Hypothesis_var aVar = myObjHyps[ dim ][ Algo ].first().first;
- HypothesisData* algoData = SMESH::GetHypothesisData( aVar->GetName() );
+ HypothesisData* algoData = SMESH::GetHypothesisData( SMESH::toQStr( aVar->GetName() ));
aHypIndex = myAvailableHypData[ dim ][ Algo ].indexOf ( algoData );
// if ( aHypIndex < 0 && algoData ) {
// // assigned algo is incompatible with other algorithms
{
// get hypotheses
existingHyps( dim, hypType, pObj, anExisting, myObjHyps[ dim ][ hypType ] );
+ if ( myObjHyps[ dim ][ hypType ].count() == 0 ) {
+ setCurrentHyp( dim, hypType, -1 );
+ }
for ( int i = 0, nb = myObjHyps[ dim ][ hypType ].count(); i < nb; ++i )
{
// find index of required hypothesis among existing ones for this dimension and type
// First, remove old algos in order to avoid messages on algorithm hiding
for ( int dim = aDim; dim <= SMESH::DIM_3D; dim++ )
{
- if ( isAccessibleDim( dim ) && myObjHyps[ dim ][ Algo ].count() > 0 )
+ if ( /*isAccessibleDim( dim ) &&*/ myObjHyps[ dim ][ Algo ].count() > 0 )
{
SMESH::SMESH_Hypothesis_var anOldAlgo = myObjHyps[ dim ][ Algo ].first().first;
SMESH::SMESH_Hypothesis_var anAlgoVar = getAlgo( dim );
if ( anAlgoVar->_is_nil() || // no new algo selected or
- strcmp(anOldAlgo->GetName(), anAlgoVar->GetName()) ) // algo change
+ SMESH::toQStr(anOldAlgo->GetName()) != SMESH::toQStr(anAlgoVar->GetName())) // algo change
{
// remove old algorithm
SMESH::RemoveHypothesisOrAlgorithmOnMesh ( pObj, myObjHyps[ dim ][ Algo ].first().first );
myDlg->setEnabled( false ); // disactivate selection
selectionMgr()->clearFilters();
selectObject( meshSO );
- SMESHGUI::GetSMESHGUI()->OnGUIEvent( 713 ); // MESH_ORDER
+ SMESHGUI::GetSMESHGUI()->OnGUIEvent( SMESHOp::OpMeshOrder ); // MESH_ORDER
qApp->processEvents();
myDlg->setEnabled( true );
* \param theIndex - Index of current type of mesh
*/
//================================================================================
-void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theIndex)
+void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theIndex )
{
- int aDim;
- THypDataList anAvailableAlgsData;
QStringList anAvailableAlgs;
- QString anCompareType = "";
- bool isAvailableChoiceAlgo = false;
- int anCurrentAvailableAlgo = 0;
+ QString anCompareType = currentMeshTypeName( theIndex );
+ int anCurrentAvailableAlgo = -1;
bool isNone = true;
- switch ( theIndex ) {
- case MT_ANY:
- anCompareType = "ANY";
- aDim = SMESH::DIM_3D;
- break;
- case MT_TRIANGULAR:
+ int aDim = SMESH::DIM_3D;
+ if ( theIndex == MT_TRIANGULAR || theIndex == MT_QUADRILATERAL)
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" )
{
+ bool isReqDisBound = false;
+ int aReqDim = SMESH::DIM_3D;
for ( int dim = SMESH::DIM_3D; dim >= SMESH::DIM_2D; dim-- )
{
+ anCurrentAvailableAlgo = -1;
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;
+ HypothesisData* algoCur = 0;
if ( !isNone && !myAvailableHypData[dim][Algo].empty() ) {
algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) );
}
- myAvailableHypData[dim][Algo].clear();
- anAvailableAlgs.clear();
- if ( dim != SMESH::DIM_2D || currentHyp( SMESH::DIM_3D, Algo ) < 0 ||
- myAvailableHypData[SMESH::DIM_3D][Algo].empty() ||
- !myAvailableHypData[SMESH::DIM_3D][Algo].at( currentHyp( SMESH::DIM_3D, Algo ) )->InputTypes.isEmpty() )
- {
- for (int i = 0 ; i < anAvailableAlgsData.count(); i++)
- {
- HypothesisData* curAlgo = anAvailableAlgsData.at(i);
- if ( aGeomVar->_is_nil() ||
- SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, toCheckIsApplicableToAll ))
- {
- anAvailableAlgs.append( curAlgo->Label );
- myAvailableHypData[dim][Algo].append( curAlgo );
- }
- }
- 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;
- }
- }
- }
- else if ( !isNone ) {
- isAvailableChoiceAlgo = true;
- anCurrentAvailableAlgo = currentHyp( dim, Algo );
- }
+ HypothesisData* prevAlgo = 0;
+ HypothesisData* nextAlgo = 0;
+ if ( dim == SMESH::DIM_2D ) {
+ prevAlgo = hypData( SMESH::DIM_1D, Algo, currentHyp( SMESH::DIM_1D, Algo ) );
+ if ( aDim == SMESH::DIM_3D )
+ nextAlgo = hypData( SMESH::DIM_3D, Algo, currentHyp( SMESH::DIM_3D, Algo ) );
}
+ // retrieves a list of available algorithms from resources
+ availableHyps( dim, Algo, anAvailableAlgs, myAvailableHypData[dim][Algo], prevAlgo, nextAlgo, anCompareType);
+ anCurrentAvailableAlgo = myAvailableHypData[dim][Algo].indexOf( algoCur );
myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
- if ( isAvailableChoiceAlgo )
- setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
+ setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
+ if ( anCurrentAvailableAlgo > -1 )
+ isReqDisBound = algoCur->InputTypes.isEmpty();
+ if ( isReqDisBound ) {
+ aReqDim = dim;
+ break;
+ }
}
if ( !myIsOnGeometry )
for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
}
else
for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
- if ( i > myMaxShapeDim ) myDlg->disableTab( i );
- else myDlg->enableTab( i );
+ if ( i > myMaxShapeDim || ( isReqDisBound && i != aReqDim ) ) myDlg->disableTab( i );
+ else myDlg->enableTab( i );
}
myDlg->setCurrentTab( theTabIndex );
}
else
{
- QString anCurrentAlgo;
+ HypothesisData* anCurrentAlgo;
bool isReqDisBound = true;
QString anCurrentCompareType = anCompareType;
isNone = currentHyp( aDim, Algo ) < 0;
- if ( !isNone && !myAvailableHypData[aDim][Algo].empty() &&
- myAvailableHypData[aDim][Algo].count() != anAvailableAlgsData.count() )
+ if ( !isNone && !myAvailableHypData[aDim][Algo].empty() )
isReqDisBound = myAvailableHypData[aDim][Algo].at( currentHyp( aDim, Algo ) )->InputTypes.isEmpty();
- else if ( !isNone )
- isReqDisBound = anAvailableAlgsData.at( currentHyp( aDim, Algo ) )->InputTypes.isEmpty();
for ( int dim = aDim; dim >= SMESH::DIM_2D; dim-- )
{
bool isNoneAlg = currentHyp( dim, Algo ) < 0;
- isAvailableChoiceAlgo = false;
- // retrieves a list of available algorithms from resources
- availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData );
+ anCurrentAvailableAlgo = -1;
+ HypothesisData* prevAlgo = 0;
+ HypothesisData* nextAlgo = 0;
+ if ( dim == SMESH::DIM_2D ) {
+ prevAlgo = hypData( SMESH::DIM_1D, Algo, currentHyp( SMESH::DIM_1D, Algo ) );
+ if ( aDim == SMESH::DIM_3D )
+ nextAlgo = hypData( SMESH::DIM_3D, Algo, currentHyp( SMESH::DIM_3D, Algo ) );
+ }
// 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++ )
- {
- 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 ( !isNoneAlg ) {
+ anCurrentAlgo = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) );
}
+ // retrieves a list of available algorithms from resources
+ availableHyps( dim, Algo, anAvailableAlgs, myAvailableHypData[dim][Algo], prevAlgo, nextAlgo, anCurrentCompareType );
+ // finding and adding algorithm depending on the type mesh
+ anCurrentAvailableAlgo = myAvailableHypData[dim][Algo].indexOf( anCurrentAlgo );
//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 );
+ anCurrentCompareType = ( anCompareType == "HEXA" || anCompareType == "QUAD" ) ? "QUAD" : "TRIA";
+ setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
}
- if ( isNone || isReqDisBound ) {
- for ( int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++ ) {
- if ( aDim != i ) {
- myDlg->disableTab( i );
- setCurrentHyp(i, Algo, -1);
- }
- }
+ if ( aDim == SMESH::DIM_2D) {
+ myDlg->disableTab( SMESH::DIM_3D );
+ setCurrentHyp( SMESH::DIM_3D, Algo, -1);
}
- else if ( !isNone ) {
- if ( aDim == SMESH::DIM_2D){
- myDlg->disableTab( SMESH::DIM_3D );
- setCurrentHyp( SMESH::DIM_3D, Algo, -1);
- }
- for ( int i = myMaxShapeDim; i > SMESH::DIM_0D; i-- )
- {
- 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--){
+ for ( int i = myMaxShapeDim; i > SMESH::DIM_0D; i-- ) {
+ bool isNoneAlg = currentHyp( i, Algo ) < 0;
+ if ( !isNoneAlg )
+ isReqDisBound = myAvailableHypData[i][Algo].at( currentHyp( i, Algo ) )->InputTypes.isEmpty();
+ else
+ isReqDisBound = true;
+ if ( isReqDisBound && !isNoneAlg) {
+ for (int j = i; j >= SMESH::DIM_0D; j--) {
+ if ( currentHyp( j, Algo ) < 0 ) {
myDlg->disableTab( j );
setCurrentHyp( j , Algo, -1 );
}
- break;
}
+ break;
}
}
- myDlg->enableTab( aDim );
- myDlg->setCurrentTab( aDim );
+ int currentTab = ( theTabIndex <= aDim ) ? theTabIndex : aDim;
+ myDlg->setCurrentTab( currentTab );
}
+ THypDataList anAvailableAlgsData;
QStringList aHypothesesSetsList = SMESH::GetHypothesesSets( aDim );
QStringList aFilteredHypothesesSetsList;
aFilteredHypothesesSetsList.clear();
QStringList::const_iterator inHypoSetName = aHypothesesSetsList.begin();
- for ( ; inHypoSetName != aHypothesesSetsList.end(); ++inHypoSetName )
- {
+ for ( ; inHypoSetName != aHypothesesSetsList.end(); ++inHypoSetName ) {
HypothesesSet* currentHypoSet = SMESH::GetHypothesesSet( *inHypoSetName );
bool isAvailable = false;
currentHypoSet->init( true );
- while ( currentHypoSet->next(), currentHypoSet->more() )
- {
+ while ( currentHypoSet->next(), currentHypoSet->more() ) {
isAvailable = false;
- if ( HypothesisData* algoDataIn = SMESH::GetHypothesisData( currentHypoSet->current() ))
- {
- for (int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++)
- {
- if ( myAvailableHypData[i][Algo].count() == 0 ) {
- availableHyps( i, Algo, anAvailableAlgs, anAvailableAlgsData );
- for ( int j = 0 ; j < anAvailableAlgsData.count(); j++ )
- {
- HypothesisData* aCurAlgo = anAvailableAlgsData.at( j );
- if ( aCurAlgo->Label == algoDataIn->Label ){
- isAvailable = true;
- break;
- }
- }
- }
- else {
- 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 ( HypothesisData* algoDataIn = SMESH::GetHypothesisData( currentHypoSet->current() )) {
+ for (int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++) {
+ int anCurrentAvailableAlgo = myAvailableHypData[i][Algo].indexOf( algoDataIn );
+ if ( anCurrentAvailableAlgo > -1 ) {
+ isAvailable = true;
+ break;
}
- if ( isAvailable ) break;
}
- if ( !isAvailable ) break;
+ if ( !isAvailable )
+ break;
}
}
if ( isAvailable )
}
myDlg->setHypoSets( aFilteredHypothesesSetsList );
}
+
+//================================================================================
+/*!
+ * \brief Get current name types of mesh
+ * \param theIndex - current index types of mesh
+ * \retval QString - result
+ */
+//================================================================================
+QString SMESHGUI_MeshOp::currentMeshTypeName( const int theIndex ) const
+{
+ QString aMeshType = "";
+ switch ( theIndex ) {
+ case MT_ANY:
+ aMeshType = "ANY";
+ break;
+ case MT_TRIANGULAR:
+ aMeshType = "TRIA";
+ break;
+ case MT_QUADRILATERAL:
+ aMeshType = "QUAD";
+ break;
+ case MT_TETRAHEDRAL:
+ aMeshType = "TETRA";
+ break;
+ case MT_HEXAHEDRAL:
+ aMeshType = "HEXA";
+ break;
+ default:;
+ }
+ return aMeshType;
+}
+
