#include <GEOMBase.h>
#include <GeometryGUI.h>
#include <GEOM_wrap.hxx>
+#include <GEOMImpl_Types.hxx>
// SALOME GUI includes
#include <SalomeApp_Tools.h>
myDlg->adjustSize();
readMesh();
}
+ int curIndex = myDlg->currentMeshType( );
QStringList TypeMeshList;
createMeshTypeList( TypeMeshList );
setAvailableMeshType( TypeMeshList );
- setFilteredAlgoData( myMaxShapeDim, myDlg->currentMeshType( ));
+ curIndex =( curIndex >= TypeMeshList.count() ) ? 0 : curIndex;
+ myDlg->setCurrentMeshType( curIndex );
+ setFilteredAlgoData( myMaxShapeDim, curIndex);
}
catch ( const SALOME::SALOME_Exception& S_ex )
{
QStringList 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 );
- setCurrentHyp(i, Algo, -1);
- }
+ // 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
if ( !algoData ) { // all algos becomes available
- if (myDlg->currentMeshType() == MT_ANY)
+ if (myDlg->currentMeshType() == MT_ANY || aDim == SMESH::DIM_1D || aDim == SMESH::DIM_0D)
availableHyps( aDim, Algo, anAvailable, myAvailableHypData[ aDim ][ Algo ]);
else{
anAvailable.clear();
int anCurrentAvailableAlgo = 0;
bool isNone = true;
switch ( theIndex ) {
- case MT_ANY:{
+ case MT_ANY:
anCompareType = "ANY";
aDim = SMESH::DIM_3D;
- }
- break;
- case MT_TRIANGULAR:{
+ break;
+ case MT_TRIANGULAR:
aDim = SMESH::DIM_2D;
anCompareType = "TRIA";
- }
- break;
- case MT_QUADRILATERAL:{
+ break;
+ case MT_QUADRILATERAL:
aDim = SMESH::DIM_2D;
anCompareType = "QUAD";
- }
- break;
- case MT_TETRAHEDRAL:{
+ break;
+ case MT_TETRAHEDRAL:
aDim = SMESH::DIM_3D;
anCompareType = "TETRA";
- }
- break;
- case MT_HEXAHEDRAL:{
+ break;
+ case MT_HEXAHEDRAL:
aDim = SMESH::DIM_3D;
anCompareType = "HEXA";
- }
- break;
+ 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++ )
availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData );
//return current algo in current tab and set new algorithm list
HypothesisData* algoCur;
- if ( !isNone && !myAvailableHypData[dim][Algo].empty() ){
+ if ( !isNone && !myAvailableHypData[dim][Algo].empty() ) {
algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) );
}
myAvailableHypData[dim][Algo].clear();
for (int i = 0 ; i < anAvailableAlgsData.count(); i++)
{
HypothesisData* curAlgo = anAvailableAlgsData.at(i);
- QString anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- GEOM::GEOM_Object_var aGeomVar = GEOM::GEOM_Object::_nil();
- if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
- {
- aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
- }
if ( aGeomVar->_is_nil() ||
- ( !aGeomVar->_is_nil() && SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, !myIsMesh ))){
+ SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, toCheckIsApplicableToAll ))
+ {
anAvailableAlgs.append( curAlgo->Label );
myAvailableHypData[dim][Algo].append( curAlgo );
}
}
- if ( !isNone && algoCur ){
+ if ( !isNone && algoCur ) {
for (int i = 0 ; i < myAvailableHypData[dim][Algo].count(); i++)
{
HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i);
}
}
}
- else if ( !isNone ){
+ else if ( !isNone ) {
isAvailableChoiceAlgo = true;
anCurrentAvailableAlgo = currentHyp( dim, Algo );
}
if ( isAvailableChoiceAlgo )
setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
}
- int aDimNotGeometry = ( myIsOnGeometry ) ? SMESH::DIM_0D : SMESH::DIM_3D;
if ( !myIsOnGeometry )
- for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ){
- myDlg->disableTab( i );
+ 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 );
}
- for ( int i = aDimNotGeometry; i <= myMaxShapeDim; i++ ) {
- myDlg->enableTab( i );
- }
myDlg->setCurrentTab( theTabIndex );
}
else
QStringList::const_iterator inElemType = algoIn->OutputTypes.begin();
for ( ; inElemType != algoIn->OutputTypes.end(); inElemType++ )
{
- if ( *inElemType == anCurrentCompareType ){
+ if ( *inElemType == anCurrentCompareType ) {
isAvailableAlgo = true;
break;
}
}
- if ( isAvailableAlgo || algoIn->OutputTypes.count()==0 ){
- QString anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- GEOM::GEOM_Object_var aGeomVar = GEOM::GEOM_Object::_nil();
- if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
- {
- aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() );
- }
+ if ( isAvailableAlgo || algoIn->OutputTypes.count()==0 ) {
if ( aGeomVar->_is_nil() || myMaxShapeDim != dim ||
- ( !aGeomVar->_is_nil() && SMESH::IsApplicable( algoIn->TypeName, aGeomVar, !myIsMesh ))){
+ 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 ){
+ if ( !isNoneAlg && isAvailableAlgo && algoIn->Label == anCurrentAlgo ) {
isAvailableChoiceAlgo = true;
anCurrentAvailableAlgo = anAvailableAlgs.count() - 1 ;
}
setCurrentHyp( dim, Algo, -1 );
}
- int aMaxShapeDim = ( myMaxShapeDim != aDim) ? aDim : myMaxShapeDim;
if ( isNone || isReqDisBound ) {
- for ( int i = SMESH::DIM_0D; i <= aMaxShapeDim; i++ ) {
+ 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);
isAvailable = false;
if ( HypothesisData* algoDataIn = SMESH::GetHypothesisData( currentHypoSet->current() ))
{
- for (int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++)
+ 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 );
