X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_MeshOp.cxx;h=9378e4d402070083339119e6913f0f636c57160e;hp=bed7c25fda6dc159638fb18e57d4e00ba54d7c87;hb=560f8b2d0c2a7fdb4047f981cfac56ed3629bc1a;hpb=2742029b9094540c12b9e30bbdb958087e0cb850 diff --git a/src/SMESHGUI/SMESHGUI_MeshOp.cxx b/src/SMESHGUI/SMESHGUI_MeshOp.cxx index bed7c25fd..9378e4d40 100644 --- a/src/SMESHGUI/SMESHGUI_MeshOp.cxx +++ b/src/SMESHGUI/SMESHGUI_MeshOp.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2016 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 @@ -26,15 +26,15 @@ #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 -#include +#include "SMESH_NumberFilter.hxx" +#include "SMESH_TypeFilter.hxx" // SALOME GEOM includes #include @@ -88,10 +88,10 @@ //================================================================================ 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 @@ -133,7 +133,7 @@ LightApp_Dialog* SMESHGUI_MeshOp::dlg() const //================================================================================ bool SMESHGUI_MeshOp::onApply() { - if (isStudyLocked()) + if (SMESHGUI::isStudyLocked()) return false; QString aMess; @@ -200,32 +200,34 @@ bool SMESHGUI_MeshOp::onApply() //================================================================================ void SMESHGUI_MeshOp::startOperation() { + myIgnoreAlgoSelection = false; + if (!myDlg) { myDlg = new SMESHGUI_MeshDlg( myToCreate, myIsMesh ); 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 ))); connect( myDlg, SIGNAL( selectMeshType( const int, const int ) ), SLOT( onAlgoSetByMeshType( const int, const int))); if ( myToCreate ) { - if ( myIsMesh ) myHelpFileName = "constructing_meshes_page.html"; - else myHelpFileName = "constructing_submeshes_page.html"; + if ( myIsMesh ) myHelpFileName = "constructing_meshes.html"; + else myHelpFileName = "constructing_submeshes.html"; } else { - myHelpFileName = "editing_meshes_page.html"; + myHelpFileName = "editing_meshes.html"; } } SMESHGUI_SelectionOp::startOperation(); - // iterate through dimensions and get available algoritms, set them to the dialog - _PTR(SComponent) aFather = SMESH::GetActiveStudyDocument()->FindComponent( "SMESH" ); + // iterate through dimensions and get available algorithms, set them to the dialog + _PTR(SComponent) aFather = SMESH::getStudy()->FindComponent( "SMESH" ); for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) { SMESHGUI_MeshTab* aTab = myDlg->tab( i ); @@ -247,8 +249,9 @@ void SMESHGUI_MeshOp::startOperation() myDlg->activateObject( myIsMesh ? SMESHGUI_MeshDlg::Geom : SMESHGUI_MeshDlg::Mesh ); } else + { myDlg->activateObject( SMESHGUI_MeshDlg::Obj ); - + } myDlg->setCurrentTab( SMESH::DIM_3D ); QStringList TypeMeshList; @@ -259,7 +262,6 @@ void SMESHGUI_MeshOp::startOperation() myDlg->setGeomPopupEnabled(false); selectionDone(); - myIgnoreAlgoSelection = false; myHasConcurrentSubBefore = false; myObjectToSelect.clear(); @@ -269,7 +271,7 @@ void SMESHGUI_MeshOp::startOperation() /*! * \brief Selects a recently created mesh or sub-mesh if necessary * - * Virtual method redefined from base class called when operation is commited + * Virtual method redefined from base class called when operation is committed * selects a recently created mesh or sub-mesh if necessary. Allows to perform * selection when the custom selection filters are removed. */ @@ -327,7 +329,7 @@ bool SMESHGUI_MeshOp::isSubshapeOk() const // mesh QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ); - _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() ); + _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() ); if (!pMesh) return false; SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface( pMesh ); @@ -343,17 +345,16 @@ bool SMESHGUI_MeshOp::isSubshapeOk() const if (aGEOMs.count() > 0) { GEOM::GEOM_Gen_var geomGen = SMESH::GetGEOMGen(); - _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); - if (geomGen->_is_nil() || !aStudy) return false; + if (geomGen->_is_nil()) return false; - GEOM::GEOM_IGroupOperations_wrap op = geomGen->GetIGroupOperations(aStudy->StudyId()); + GEOM::GEOM_IGroupOperations_wrap op = geomGen->GetIGroupOperations(); if (op->_is_nil()) return false; // check all selected shapes QStringList::const_iterator aSubShapesIter = aGEOMs.begin(); for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++) { QString aSubGeomEntry = (*aSubShapesIter); - _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.toLatin1().data()); + _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toUtf8().data()); if (!pSubGeom) return false; GEOM::GEOM_Object_var aSubGeomVar = @@ -373,7 +374,7 @@ bool SMESHGUI_MeshOp::isSubshapeOk() const if ( aSubGeomVar->GetShapeType() == GEOM::COMPOUND ) { // is aSubGeomVar a compound of sub-shapes? - GEOM::GEOM_IShapesOperations_wrap sop = geomGen->GetIShapesOperations(aStudy->StudyId()); + GEOM::GEOM_IShapesOperations_wrap sop = geomGen->GetIShapesOperations(); if (sop->_is_nil()) return false; GEOM::ListOfLong_var ids = sop->GetAllSubShapesIDs( aSubGeomVar, GEOM::SHAPE,/*sorted=*/false); @@ -387,8 +388,11 @@ bool SMESHGUI_MeshOp::isSubshapeOk() const compSub, compSub->GetShapeType() ); geomGen->RemoveObject( compSub ); - if ( shared->length() > 0 ) + compSub->UnRegister(); + if ( shared->length() > 0 ) { geomGen->RemoveObject( shared[0] ); + shared[0]->UnRegister(); + } return ( shared->length() > 0 ); } } @@ -401,8 +405,8 @@ bool SMESHGUI_MeshOp::isSubshapeOk() const //================================================================================ /*! - * \brief Return name of the algorithm that does not support submeshes and makes - * submesh creation useless + * \brief Return name of the algorithm that does not support sub-meshes and makes + * sub-mesh creation useless * \retval char* - string is to be deleted!!! */ //================================================================================ @@ -412,7 +416,7 @@ char* SMESHGUI_MeshOp::isSubmeshIgnored() const QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ); QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom ); - _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() ); + _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() ); if ( pMesh ) { QStringList algoNames; @@ -424,11 +428,11 @@ char* SMESHGUI_MeshOp::isSubmeshIgnored() const if ( algo && algo->InputTypes.empty() && // builds all dimensions it-self !algo->IsSupportSubmeshes ) - return CORBA::string_dup( algoNames[0].toLatin1().data() ); + return CORBA::string_dup( algoNames[0].toUtf8().data() ); } // GEOM::GEOM_Object_var geom; -// if (_PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() )) +// if (_PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() )) // geom = SMESH::SObjectToInterface( pGeom ); // if ( !geom->_is_nil() && geom->GetShapeType() >= GEOM::FACE ) { // WIRE, EDGE as well @@ -439,7 +443,7 @@ char* SMESHGUI_MeshOp::isSubmeshIgnored() const if ( algo && algo->InputTypes.empty() && // builds all dimensions it-self !algo->IsSupportSubmeshes ) - return CORBA::string_dup( algoNames[0].toLatin1().data() ); + return CORBA::string_dup( algoNames[0].toUtf8().data() ); } // } } @@ -457,8 +461,8 @@ _PTR(SObject) SMESHGUI_MeshOp::getSubmeshByGeom() const { QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ); QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom ); - _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() ); - _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() ); + _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() ); + _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() ); if ( pMesh && pGeom ) { GEOM::GEOM_Object_var geom = SMESH::SObjectToInterface( pGeom ); if ( !geom->_is_nil() ) { @@ -475,7 +479,7 @@ _PTR(SObject) SMESHGUI_MeshOp::getSubmeshByGeom() const } _PTR(GenericAttribute) anAttr; _PTR(SObject) aSubmeshRoot; - _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); + _PTR(Study) aStudy = SMESH::getStudy(); if ( pMesh->FindSubObject( tag, aSubmeshRoot ) ) { _PTR(ChildIterator) smIter = aStudy->NewChildIterator( aSubmeshRoot ); @@ -518,7 +522,7 @@ void SMESHGUI_MeshOp::selectionDone() //Check geometry for mesh QString anObjEntry = myDlg->selectedObject(SMESHGUI_MeshDlg::Obj); - _PTR(SObject) pObj = studyDS()->FindObjectID(anObjEntry.toLatin1().data()); + _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID(anObjEntry.toUtf8().data()); if (pObj) { SMESH::SMESH_Mesh_var aMeshVar = @@ -546,15 +550,23 @@ void SMESHGUI_MeshOp::selectionDone() int iSubSh = 0; 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; + _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toUtf8().data()); + + 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 QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ); - _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() ); + _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() ); GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj ); if (!aGeomVar->_is_nil()) { aSeq->length(1); @@ -564,7 +576,7 @@ void SMESHGUI_MeshOp::selectionDone() 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; @@ -625,13 +637,14 @@ void SMESHGUI_MeshOp::selectionDone() { SMESH::SMESH_subMesh_var submeshVar = SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() ); + myIsMesh = submeshVar->_is_nil(); + myDlg->setTitile( myToCreate, myIsMesh ); 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(); - myIsMesh = submeshVar->_is_nil(); readMesh(); } else @@ -654,7 +667,7 @@ void SMESHGUI_MeshOp::selectionDone() { selectionMgr()->clearFilters(); selectObject( pSubmesh ); - SMESHGUI::GetSMESHGUI()->switchToOperation(704); + SMESHGUI::GetSMESHGUI()->switchToOperation( SMESHOp::OpEditMeshOrSubMesh ); return; } else @@ -680,12 +693,12 @@ void SMESHGUI_MeshOp::selectionDone() // enable/disable popup for choice of geom selection way bool enable = false; QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ); - if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() )) { + if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() )) { SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface( pMesh ); if ( !mesh->_is_nil() ) { //rnv: issue 21056: EDF 1608 SMESH: Dialog Box "Create Sub Mesh": focus should automatically switch to geometry QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom ); - _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() ); + _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() ); if ( !pGeom || GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() )->_is_nil() ) myDlg->activateObject(SMESHGUI_MeshDlg::Geom); enable = ( shapeDim > 1 ) && ( mesh->NbEdges() > 0 ); @@ -695,15 +708,14 @@ void SMESHGUI_MeshOp::selectionDone() } } else { // no geometry defined - myDlg->enableTab( SMESH::DIM_3D ); - QStringList hypList; - availableHyps( SMESH::DIM_3D, Algo, hypList, - myAvailableHypData[SMESH::DIM_3D][Algo]); - SMESHGUI_MeshTab* aTab = myDlg->tab( SMESH::DIM_3D ); - aTab->setAvailableHyps( Algo, hypList ); - for (int i = SMESH::DIM_0D;i < SMESH::DIM_3D; ++i) { - myDlg->disableTab(i); + QStringList hypList; + for ( int dim = SMESH::DIM_0D; dim <= SMESH::DIM_3D; dim++ ) + { + availableHyps( dim, Algo, hypList, myAvailableHypData[dim][Algo]); + myDlg->tab( dim )->setAvailableHyps( Algo, hypList ); + if ( hypList.empty() ) myDlg->disableTab( dim ); + else myDlg->enableTab( dim ); } myMaxShapeDim = -1; //Hide labels and fields (Mesh and Geometry) @@ -761,7 +773,7 @@ bool SMESHGUI_MeshOp::isValid( QString& theMess ) const { QString aMeshEntry = myDlg->selectedObject ( myToCreate ? SMESHGUI_MeshDlg::Mesh : SMESHGUI_MeshDlg::Obj ); - if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() )) { + if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() )) { SMESH::SMESH_Mesh_var mesh = SMESH::SObjectToInterface( pMesh ); if ( !mesh->_is_nil() && CORBA::is_nil( mesh->GetShapeToMesh() )) { theMess = tr( "IMPORTED_MESH" ); @@ -790,7 +802,7 @@ bool SMESHGUI_MeshOp::isValid( QString& theMess ) const } return true; } - _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() ); + _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() ); if ( !pGeom || GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() )->_is_nil() ) { theMess = tr( "GEOMETRY_OBJECT_IS_NULL" ); @@ -806,7 +818,7 @@ bool SMESHGUI_MeshOp::isValid( QString& theMess ) const theMess = tr( "MESH_IS_NOT_DEFINED" ); return false; } - _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() ); + _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() ); if ( !pMesh || SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() )->_is_nil() ) { theMess = tr( "MESH_IS_NULL" ); @@ -847,6 +859,60 @@ static bool isCompatible(const HypothesisData* theAlgoData, 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 @@ -854,7 +920,9 @@ static bool isCompatible(const HypothesisData* theAlgoData, * \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 */ @@ -863,7 +931,9 @@ void SMESHGUI_MeshOp::availableHyps( const int theDim, const int theHypType, QStringList& theHyps, THypDataList& theDataList, - HypothesisData* theAlgoData ) const + HypothesisData* thePrevAlgoData, + HypothesisData* theNextAlgoData, + const QString& theMeshType) { theDataList.clear(); theHyps.clear(); @@ -871,15 +941,62 @@ void SMESHGUI_MeshOp::availableHyps( const int theDim, bool isAux = ( theHypType >= AddHyp ); QStringList aHypTypeNameList = SMESH::GetAvailableHypotheses( isAlgo, theDim, isAux, myIsOnGeometry, !myIsMesh ); + GEOM::GEOM_Object_var aGeomVar; + QString aCurrentGeomToSelect; + if ( !theMeshType.isEmpty() ) { + aCurrentGeomToSelect = myDlg->selectedObject( myToCreate ? SMESHGUI_MeshDlg::Geom : SMESHGUI_MeshDlg::Obj ); + if ( _PTR(SObject) so = SMESH::getStudy()->FindObjectID( aCurrentGeomToSelect.toUtf8().data() )) { + aGeomVar = SMESH::GetGeom( so ); + } + if ( aCurrentGeomToSelect != myLastGeomToSelect ) + myHypMapIsApplicable.clear(); + } + + std::multimap< double, HypothesisData* > sortedHyps; QStringList::const_iterator anIter; 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; + + int groupID = aData->GroupID; + int priority = aData->Priority; + if ( groupID < 0 || groupID > 9 ) groupID = 9; + if ( priority < 0 || priority > 999 ) priority = 999; + + sortedHyps.insert( std::make_pair( groupID + priority * 1e-3, aData )); + } + } + + if ( !sortedHyps.empty() ) + { + HypothesisData* aPrevGroup = SMESH::GetGroupTitle( sortedHyps.rbegin()->second, isAlgo ); + std::multimap< double, HypothesisData* >::iterator key_hyp = sortedHyps.begin(); + for ( ; key_hyp != sortedHyps.end(); ++key_hyp ) + { + HypothesisData* aData = key_hyp->second; + HypothesisData* aGroup = SMESH::GetGroupTitle( aData, isAlgo ); + if ( aPrevGroup != aGroup ) + { + theDataList.append( aGroup ); + theHyps.append( aGroup->Label ); + aPrevGroup = aGroup; + } theDataList.append( aData ); theHyps.append( aData->Label ); } } + + if ( !theMeshType.isEmpty() && !aCurrentGeomToSelect.isEmpty() ) + myLastGeomToSelect = aCurrentGeomToSelect; } //================================================================================ @@ -932,8 +1049,7 @@ void SMESHGUI_MeshOp::existingHyps( const int theDim, if ( theFather->FindSubObject( aPart, aHypRoot ) ) { - _PTR(ChildIterator) anIter = - SMESH::GetActiveStudyDocument()->NewChildIterator( aHypRoot ); + _PTR(ChildIterator) anIter = SMESH::getStudy()->NewChildIterator( aHypRoot ); for ( ; anIter->More(); anIter->Next() ) { _PTR(SObject) anObj = anIter->Value(); @@ -1004,14 +1120,14 @@ SMESHGUI_MeshOp::getInitParamsHypothesis( const QString& aHypType, { anEntry = myDlg->selectedObject ( myToCreate ? SMESHGUI_MeshDlg::Mesh : SMESHGUI_MeshDlg::Obj ); - if ( _PTR(SObject) pObj = studyDS()->FindObjectID( anEntry.toLatin1().data() )) + if ( _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anEntry.toUtf8().data() )) { CORBA::Object_ptr Obj = _CAST( SObject,pObj )->GetObject(); if ( myToCreate ) // mesh and geom may be selected { aMeshVar = SMESH::SMESH_Mesh::_narrow( Obj ); anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom ); - if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.toLatin1().data() )) + if ( _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( anEntry.toUtf8().data() )) aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() ); } else // edition: sub-mesh may be selected @@ -1029,7 +1145,7 @@ SMESHGUI_MeshOp::getInitParamsHypothesis( const QString& aHypType, if ( !myToCreate ) // mesh to edit can be selected { anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ); - if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( anEntry.toLatin1().data() )) + if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( anEntry.toUtf8().data() )) { aMeshVar = SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() ); if ( !aMeshVar->_is_nil() ) @@ -1038,7 +1154,7 @@ SMESHGUI_MeshOp::getInitParamsHypothesis( const QString& aHypType, } if ( aGeomVar->_is_nil() ) { anEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom ); - if ( _PTR(SObject) pGeom = studyDS()->FindObjectID( anEntry.toLatin1().data() )) + if ( _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( anEntry.toUtf8().data() )) { aGeomVar= GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() ); } @@ -1046,14 +1162,14 @@ SMESHGUI_MeshOp::getInitParamsHypothesis( const QString& aHypType, } SMESH::SMESH_Hypothesis_var hyp = - SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType.toLatin1().data(), - aServerLib.toLatin1().data(), + SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType.toUtf8().data(), + aServerLib.toUtf8().data(), aMeshVar, aGeomVar, /*byMesh = */isSubMesh); if ( hyp->_is_nil() && isSubMesh ) hyp = SMESHGUI::GetSMESHGen()->GetHypothesisParameterValues( aHypType.toLatin1().data(), - aServerLib.toLatin1().data(), + aServerLib.toUtf8().data(), aMeshVar, aGeomVar, /*byMesh = */false); @@ -1073,24 +1189,21 @@ void SMESHGUI_MeshOp::initHypCreator( SMESHGUI_GenericHypothesisCreator* theCrea // Set shapes, of mesh and sub-mesh if any // get Entry of the Geom object - QString aGeomEntry = ""; - QString aMeshEntry = ""; - QString anObjEntry = ""; - aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom ); - aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ); - anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ); + QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom ); + QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ); + QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ); if ( myToCreate && myIsMesh ) aMeshEntry = aGeomEntry; if ( aMeshEntry != aGeomEntry ) { // Get Geom object from Mesh of a sub-mesh being edited - _PTR(SObject) pObj = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() ); + _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() ); GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj ); aMeshEntry = ( aGeomVar->_is_nil() ) ? QString() : SMESH::toQStr( aGeomVar->GetStudyEntry() ); } if ( aMeshEntry == "" && aGeomEntry == "" ) { // get geom of an object being edited - _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() ); + _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() ); bool isMesh; GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj, &isMesh ); if ( !aGeomVar->_is_nil() ) @@ -1103,7 +1216,7 @@ void SMESHGUI_MeshOp::initHypCreator( SMESHGUI_GenericHypothesisCreator* theCrea if ( anObjEntry != "" && aGeomEntry != "" && aMeshEntry == "" ) { // take geometry from submesh being created - _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() ); + _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() ); if ( pObj ) { // if current object is sub-mesh SMESH::SMESH_subMesh_var aSubMeshVar = @@ -1123,14 +1236,16 @@ void SMESHGUI_MeshOp::initHypCreator( SMESHGUI_GenericHypothesisCreator* theCrea theCreator->setShapeEntry( aGeomEntry ); if ( aMeshEntry != "" ) theCreator->setMainShapeEntry( aMeshEntry ); + + theCreator->setNoGeomMesh( !myIsOnGeometry && myIsMesh && !myToCreate ); } //================================================================================ /*! - * \Brief Returns tab dimention + * \Brief Returns tab dimension * \param tab - the tab in the dlg * \param dlg - my dialogue - * \retval int - dimention + * \retval int - dimension */ //================================================================================ static int getTabDim (const QObject* tab, SMESHGUI_MeshDlg* dlg ) @@ -1146,7 +1261,7 @@ static int getTabDim (const QObject* tab, SMESHGUI_MeshDlg* dlg ) /*! * \brief Create hypothesis * \param theHypType - hypothesis category (main or additional) - * \param theIndex - index of type of hypothesis to be cerated + * \param theIndex - index of type of hypothesis to be created * * Specifies dimension of hypothesis to be created (using sender() method), * specifies its type and calls method for hypothesis creation @@ -1249,7 +1364,8 @@ void SMESHGUI_MeshOp::createHypothesis(const int theDim, aCreator->create(initParamHyp, aHypName, myDlg, this, SLOT( onHypoCreated( int ) ) ); dialog = true; } - else { + else + { SMESH::SMESH_Hypothesis_var aHyp = SMESH::CreateHypothesis(theTypeName, aHypName, false); aHyp.out(); @@ -1278,7 +1394,7 @@ void SMESHGUI_MeshOp::onHypoCreated( int result ) myDlg->setEnabled( true ); } - _PTR(SComponent) aFather = SMESH::GetActiveStudyDocument()->FindComponent("SMESH"); + _PTR(SComponent) aFather = SMESH::getStudy()->FindComponent("SMESH"); int nbHyp = myExistingHyps[myDim][myType].count(); HypothesisData* algoData = hypData( myDim, Algo, currentHyp( myDim, Algo )); @@ -1386,18 +1502,11 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, if ( myIgnoreAlgoSelection ) return; - int aDim = theDim < 0 ? getTabDim( sender(), myDlg ): theDim; + int curDim = getTabDim( sender(), myDlg ); + int aDim = theDim < 0 ? curDim : theDim; if (aDim == -1) return; - // find highest available dimension, all algos of this dimension are available for choice - int aTopDim = -1; - for (int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++) - if (isAccessibleDim( i )) - aTopDim = i; - if (aTopDim == -1) - return; - const bool isSubmesh = ( myToCreate ? !myIsMesh : myDlg->isObjectShown( SMESHGUI_MeshDlg::Mesh )); HypothesisData* algoData = hypData( aDim, Algo, theIndex ); @@ -1406,45 +1515,37 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, QStringList anAvailable; - // 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 || 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 ); + // enable / disable tabs + if ( myIsOnGeometry ) { + for (int i = SMESH::DIM_3D; i >= SMESH::DIM_0D; i--) { + if ( i > aDim ) { + if ( i > myMaxShapeDim ) myDlg->disableTab( i ); + else myDlg->enableTab( i ); + } + else if ( i == aDim ) { + continue; + } + else {//( i < aDim ) + if ( algoData && algoData->InputTypes.isEmpty() ) { + myDlg->disableTab( i ); + for ( int type = Algo, nbTypes = nbDlgHypTypes(i); type < nbTypes; type++ ) + setCurrentHyp(i, type, -1); + } + 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; @@ -1459,52 +1560,55 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, 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; - } - // 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 ); - } - } + + 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 algorithms + 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 == curDim ) { // select the sole compatible algo - algoIndex = myAvailableHypData[dim][Algo].indexOf( soleCompatible ); - setCurrentHyp( dim, Algo, algoIndex); + algoIndex = 0; + } + setCurrentHyp( dim, Algo, algoIndex ); // remember current algo prevAlgo = algoByDim[ dim ] = hypData( dim, Algo, algoIndex ); + + } // loop on dims + + if ( myMaxShapeDim == SMESH::DIM_3D && forward && algoDim == SMESH::DIM_1D ) + { + algoDim = SMESH::DIM_3D; + forward = -1; + a3DAlgo = prevAlgo; + continue; } - } + } // loops backward and forward - // set hypotheses corresponding to the found algoritms - _PTR(SObject) pObj = SMESH::GetActiveStudyDocument()->FindComponent("SMESH"); + // set hypotheses corresponding to the found algorithms + + _PTR(SObject) pObj = SMESH::getStudy()->FindComponent("SMESH"); for ( int dim = SMESH::DIM_0D; dim <= SMESH::DIM_3D; dim++ ) { @@ -1541,7 +1645,7 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, 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)) @@ -1557,7 +1661,7 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, { // 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(); } @@ -1576,7 +1680,8 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, hypIndex = this->find( curHyp, myExistingHyps[ dim ][ type ]); else hypIndex = -1; - if ( !isSubmesh && myToCreate && hypIndex < 0 && anExisting.count() == 1 ) { + if ( !isSubmesh && myToCreate && hypIndex < 0 && anExisting.count() == 1 && dim == curDim ) + { // none is yet selected => select the sole existing if it is not optional CORBA::String_var hypTypeName = myExistingHyps[ dim ][ type ].first().first->GetName(); bool isOptional = true; @@ -1722,7 +1827,7 @@ bool SMESHGUI_MeshOp::createMesh( QString& theMess, QStringList& theEntryList ) for ( int i = 0; it!=aList.end(); it++, ++i ) { QString aGeomEntry = *it; - _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() ); + _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() ); GEOM::GEOM_Object_var aGeomVar = GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() ); @@ -1789,7 +1894,7 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess, QStringList& theEntryList // get mesh object QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ); - _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() ); + _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() ); SMESH::SMESH_Mesh_var aMeshVar = SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() ); if (aMeshVar->_is_nil()) @@ -1809,17 +1914,16 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess, QStringList& theEntryList { //QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom ); QString aGeomEntry = aGEOMs.first(); - _PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() ); + _PTR(SObject) pGeom = SMESH::getStudy()->FindObjectID( aGeomEntry.toUtf8().data() ); aGeomVar = GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() ); } else if (aGEOMs.count() > 1) { // create a GEOM group GEOM::GEOM_Gen_var geomGen = SMESH::GetGEOMGen(); - _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); - if (!geomGen->_is_nil() && aStudy) { + if (!geomGen->_is_nil()) { GEOM::GEOM_IGroupOperations_wrap op = - geomGen->GetIGroupOperations(aStudy->StudyId()); + geomGen->GetIGroupOperations(); if (!op->_is_nil()) { // check and add all selected GEOM objects: they must be // a sub-shapes of the main GEOM and must be of one type @@ -1830,7 +1934,7 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess, QStringList& theEntryList QStringList::const_iterator aSubShapesIter = aGEOMs.begin(); for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) { QString aSubGeomEntry = (*aSubShapesIter); - _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.toLatin1().data()); + _PTR(SObject) pSubGeom = SMESH::getStudy()->FindObjectID(aSubGeomEntry.toUtf8().data()); GEOM::GEOM_Object_var aSubGeomVar = GEOM::GEOM_Object::_narrow(_CAST(SObject,pSubGeom)->GetObject()); TopAbs_ShapeEnum aSubShapeType = (TopAbs_ShapeEnum)aSubGeomVar->GetShapeType(); @@ -1853,10 +1957,9 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess, QStringList& theEntryList // publish the GEOM group in study QString aNewGeomGroupName ("Auto_group_for_"); aNewGeomGroupName += aName; - SALOMEDS::Study_var aStudyVar = _CAST(Study, aStudy)->GetStudy(); SALOMEDS::SObject_wrap aNewGroupSO = - geomGen->AddInStudy( aStudyVar, aGeomVar, - aNewGeomGroupName.toLatin1().data(), mainGeom); + geomGen->AddInStudy( aGeomVar, + aNewGeomGroupName.toUtf8().data(), mainGeom); } } } @@ -1869,10 +1972,10 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess, QStringList& theEntryList SUIT_OverrideCursor aWaitCursor; // create sub-mesh - SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aName.toLatin1().data() ); + SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aName.toUtf8().data() ); _PTR(SObject) aSubMeshSO = SMESH::FindSObject( aSubMeshVar.in() ); if ( aSubMeshSO ) { - SMESH::SetName( aSubMeshSO, aName.toLatin1().data() ); + SMESH::SetName( aSubMeshSO, aName.toUtf8().data() ); theEntryList.append( aSubMeshSO->GetID().c_str() ); } @@ -1932,6 +2035,9 @@ int SMESHGUI_MeshOp::currentHyp( const int theDim, const int theHypType ) const bool SMESHGUI_MeshOp::isSelectedHyp( int theDim, int theHypType, int theIndex) const { + if ( theIndex < 0 ) + return false; + if ( theHypType < AddHyp ) // only one hyp can be selected return currentHyp( theDim, theHypType ) == theIndex; @@ -1972,17 +2078,28 @@ bool SMESHGUI_MeshOp::isAccessibleDim( const int theDim ) const * \param theDim - dimension of hypothesis or algorithm * \param theHypType - Type of hypothesis (Algo, MainHyp, AddHyp) * \param theIndex - Index of hypothesis + * \param updateHypsOnAlgoDeselection - to clear and disable hyps if algo deselected * * Gets current hypothesis or algorithms */ //================================================================================ -void SMESHGUI_MeshOp::setCurrentHyp( const int theDim, - const int theHypType, - const int theIndex ) +void SMESHGUI_MeshOp::setCurrentHyp( const int theDim, + const int theHypType, + const int theIndex, + const bool updateHypsOnAlgoDeselection) { myIgnoreAlgoSelection = true; myDlg->tab( theDim )->setCurrentHyp( theHypType, theIndex + 1 ); myIgnoreAlgoSelection = false; + + if ( updateHypsOnAlgoDeselection && theHypType == Algo && theIndex < 0 ) + { + const QStringList noHyps; + myDlg->tab( theDim )->setAvailableHyps( MainHyp, noHyps ); + myDlg->tab( theDim )->setExistingHyps ( MainHyp, noHyps ); + myDlg->tab( theDim )->setAvailableHyps( AddHyp, noHyps ); + myDlg->tab( theDim )->setExistingHyps ( AddHyp, noHyps ); + } } //================================================================================ @@ -1996,7 +2113,7 @@ void SMESHGUI_MeshOp::setDefaultName( const QString& thePrefix ) const { QString aResName; - _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); + _PTR(Study) aStudy = SMESH::getStudy(); int i = 1; QString aPrefix = thePrefix; @@ -2007,7 +2124,7 @@ void SMESHGUI_MeshOp::setDefaultName( const QString& thePrefix ) const do { aResName = aPrefix + QString::number( i++ ); - anObj = aStudy->FindObject( aResName.toLatin1().data() ); + anObj = aStudy->FindObject( aResName.toUtf8().data() ); } while ( anObj ); @@ -2036,8 +2153,8 @@ SMESH::SMESH_Hypothesis_var SMESHGUI_MeshOp::getAlgo( const int theDim ) return anAlgoVar; QString aHypName = dataList[ aHypIndex ]->TypeName; - // get existing algoritms - _PTR(SObject) pObj = SMESH::GetActiveStudyDocument()->FindComponent("SMESH"); + // get existing algorithms + _PTR(SObject) pObj = SMESH::getStudy()->FindComponent("SMESH"); QStringList tmp; existingHyps( theDim, Algo, pObj, tmp, myExistingHyps[ theDim ][ Algo ]); @@ -2064,7 +2181,7 @@ SMESH::SMESH_Hypothesis_var SMESHGUI_MeshOp::getAlgo( const int theDim ) { // Call hypothesis creation server method (without GUI) SMESH::SMESH_Hypothesis_var aHyp = - SMESH::CreateHypothesis(aHypName, aHypName, true); + SMESH::CreateHypothesis(aHypName, aHypData->Label, true); aHyp.out(); } else @@ -2077,12 +2194,13 @@ SMESH::SMESH_Hypothesis_var SMESHGUI_MeshOp::getAlgo( const int theDim ) aCreator->create( true, aHypName, myDlg, 0, QString::null ); else { SMESH::SMESH_Hypothesis_var aHyp = - SMESH::CreateHypothesis(aHypName, aHypName, true); + SMESH::CreateHypothesis(aHypName, aHypData->Label, true); aHyp.out(); } + delete aCreator; } QStringList tmpList; - _PTR(SComponent) aFather = SMESH::GetActiveStudyDocument()->FindComponent( "SMESH" ); + _PTR(SComponent) aFather = SMESH::getStudy()->FindComponent( "SMESH" ); existingHyps( theDim, Algo, aFather, tmpList, myExistingHyps[ theDim ][ Algo ] ); } @@ -2111,7 +2229,7 @@ SMESH::SMESH_Hypothesis_var SMESHGUI_MeshOp::getAlgo( const int theDim ) void SMESHGUI_MeshOp::readMesh() { QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ); - _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() ); + _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() ); if ( !pObj ) return; @@ -2139,7 +2257,7 @@ void SMESHGUI_MeshOp::readMesh() // Get hypotheses and algorithms assigned to the mesh/sub-mesh QStringList anExisting; - const int lastDim = ( myIsOnGeometry ) ? SMESH::DIM_0D : SMESH::DIM_3D; + const int lastDim = ( myIsOnGeometry ) ? SMESH::DIM_0D : SMESH::DIM_2D; bool algoFound = false; for ( int dim = SMESH::DIM_3D; dim >= lastDim; --dim ) { @@ -2150,7 +2268,7 @@ void SMESHGUI_MeshOp::readMesh() 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 @@ -2173,6 +2291,9 @@ void SMESHGUI_MeshOp::readMesh() { // 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 @@ -2260,7 +2381,7 @@ int SMESHGUI_MeshOp::find( const SMESH::SMESH_Hypothesis_var& theHyp, /*! * \brief Edits mesh or sub-mesh * \param theMess - Output parameter intended for returning error message - * \retval bool - TRUE if mesh is edited succesfully, FALSE otherwise + * \retval bool - TRUE if mesh is edited successfully, FALSE otherwise * * Assigns new name hypotheses and algoriths to the mesh or sub-mesh */ @@ -2274,7 +2395,7 @@ bool SMESHGUI_MeshOp::editMeshOrSubMesh( QString& theMess ) return false; QString anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ); - _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() ); + _PTR(SObject) pObj = SMESH::getStudy()->FindObjectID( anObjEntry.toUtf8().data() ); if ( !pObj ) return false; @@ -2283,17 +2404,17 @@ bool SMESHGUI_MeshOp::editMeshOrSubMesh( QString& theMess ) // Set new name QString aName = myDlg->objectText( SMESHGUI_MeshDlg::Obj ); SMESH::SetName( pObj, aName ); - int aDim = ( myIsOnGeometry ) ? SMESH::DIM_0D : SMESH::DIM_3D; + int aDim = ( myIsOnGeometry ) ? SMESH::DIM_0D : SMESH::DIM_2D; // 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 ); @@ -2313,7 +2434,7 @@ bool SMESHGUI_MeshOp::editMeshOrSubMesh( QString& theMess ) // Assign new algorithms and hypotheses for ( int dim = aDim; dim <= SMESH::DIM_3D; dim++ ) { - if ( !isAccessibleDim( dim )) continue; + //if ( !isAccessibleDim( dim )) continue; // find or create algorithm SMESH::SMESH_Hypothesis_var anAlgoVar = getAlgo( dim ); @@ -2404,7 +2525,7 @@ bool SMESHGUI_MeshOp::checkSubMeshConcurrency(SMESH::SMESH_Mesh_ptr mesh, 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 ); @@ -2430,7 +2551,7 @@ bool SMESHGUI_MeshOp::checkSubMeshConcurrency(SMESH::SMESH_Mesh_ptr mesh, * * method redefined from base class verifies whether given operator is valid for * this one (i.e. can be started "above" this operator). In current implementation method - * retuns false if theOtherOp operation is not intended for deleting objects or mesh + * returns false if theOtherOp operation is not intended for deleting objects or mesh * elements. */ //================================================================================ @@ -2457,7 +2578,7 @@ void SMESHGUI_MeshOp::onGeomSelectionByMesh( bool theByMesh ) } // set mesh object to SMESHGUI_ShapeByMeshOp and start it QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ); - if ( _PTR(SObject) pMesh = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() )) { + if ( _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() )) { SMESH::SMESH_Mesh_var aMeshVar = SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() ); if ( !aMeshVar->_is_nil() ) { @@ -2486,7 +2607,7 @@ void SMESHGUI_MeshOp::onPublishShapeByMeshDlg(SUIT_Operation* op) if ( !aGeomVar->_is_nil() ) { QString ID = SMESH::toQStr( aGeomVar->GetStudyEntry() ); - if ( _PTR(SObject) aGeomSO = studyDS()->FindObjectID( ID.toLatin1().data() )) { + if ( _PTR(SObject) aGeomSO = SMESH::getStudy()->FindObjectID( ID.toUtf8().data() )) { selectObject( aGeomSO ); selectionDone(); } @@ -2564,7 +2685,7 @@ void SMESHGUI_MeshOp::setAvailableMeshType( const QStringList& theTypeMesh ) * \param theIndex - Index of current type of mesh */ //================================================================================ -void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex) +void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex ) { setFilteredAlgoData( theTabIndex, theIndex); } @@ -2576,242 +2697,141 @@ void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theI * \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: - aDim = SMESH::DIM_2D; - anCompareType = "TRIA"; - break; - case MT_QUADRILATERAL: + int aDim = SMESH::DIM_3D; + if ( theIndex == MT_TRIANGULAR || theIndex == 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++ ) { - if ( i < SMESH::DIM_3D ) myDlg->disableTab( i ); - else myDlg->enableTab( i ); + bool disable = myAvailableHypData[i][Algo].isEmpty(); + if ( disable ) 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 ); + if ( i > myMaxShapeDim || ( isReqDisBound && i < aReqDim ) ) myDlg->disableTab( i ); + else myDlg->enableTab( i ); } myDlg->setCurrentTab( theTabIndex ); } else { - QString anCurrentAlgo; + HypothesisData* anCurrentAlgo = 0; 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, /*updateHyps=*/true ); } - 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 ) { - 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 && i <= aDim) { + for (int j = myMaxShapeDim; j >= SMESH::DIM_0D; j--) { + if ( currentHyp( j, Algo ) < 0 ) { myDlg->disableTab( j ); - setCurrentHyp( j , Algo, -1 ); + setCurrentHyp( j , Algo, -1, /*updateHyps=*/true ); } - break; } + break; } + else { + myDlg->enableTab( i ); + } + } + if ( aDim == SMESH::DIM_2D) { + setCurrentHyp( SMESH::DIM_3D, Algo, -1, /*updateHyps=*/true ); + myDlg->disableTab( SMESH::DIM_3D ); } - 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 ) @@ -2819,3 +2839,35 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI } 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; +} +