-// 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;
// skl for NPAL14695 - implementation of searching of mainObj
GEOM::GEOM_Object_var mainObj = op->GetMainShape(aSubGeomVar); /* _var not _wrap as
mainObj already exists! */
- while(1) {
- if (mainObj->_is_nil())
- return false;
+ while( !mainObj->_is_nil()) {
CORBA::String_var entry1 = mainObj->GetEntry();
CORBA::String_var entry2 = mainGeom->GetEntry();
if (std::string( entry1.in() ) == entry2.in() )
return true;
mainObj = op->GetMainShape(mainObj);
}
+ if ( aSubGeomVar->GetShapeType() == GEOM::COMPOUND )
+ {
+ // is aSubGeomVar a compound of sub-shapes?
+ GEOM::GEOM_IShapesOperations_wrap sop = geomGen->GetIShapesOperations(aStudy->StudyId());
+ if (sop->_is_nil()) return false;
+ GEOM::ListOfLong_var ids = sop->GetAllSubShapesIDs( aSubGeomVar,
+ GEOM::SHAPE,/*sorted=*/false);
+ if ( ids->length() > 0 )
+ {
+ ids->length( 1 );
+ GEOM::GEOM_Object_var compSub = geomGen->AddSubShape( aSubGeomVar, ids );
+ if ( !compSub->_is_nil() )
+ {
+ GEOM::ListOfGO_var shared = sop->GetSharedShapes( mainGeom,
+ compSub,
+ compSub->GetShapeType() );
+ geomGen->RemoveObject( compSub );
+ compSub->UnRegister();
+ if ( shared->length() > 0 ) {
+ geomGen->RemoveObject( shared[0] );
+ shared[0]->UnRegister();
+ }
+ return ( shared->length() > 0 );
+ }
+ }
+ }
}
}
//================================================================================
/*!
- * \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!!!
*/
//================================================================================
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;
myDlg->objectWg( SMESHGUI_MeshDlg::Geom, SMESHGUI_MeshDlg::Btn )->hide();
myDlg->updateGeometry();
myDlg->adjustSize();
- readMesh();
myIsMesh = submeshVar->_is_nil();
+ readMesh();
}
else
myDlg->reset();
{
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();
bool isAlgo = ( theHypType == Algo );
- bool isAux = ( theHypType == AddHyp );
+ bool isAux = ( theHypType >= AddHyp );
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;
}
//================================================================================
* \param theAlgoData - to select hypos able to be used by this algo (optional)
*
* Gets existing (i.e. already created) hypotheses or algorithm in accordance with
- * input parameters
+ * input parameters.
+ *
+ * WARNING: when using this method to get hyps existing in Mesh component,
+ * call availableHyps() before in order to get only hyps of available types
+ * that was filtered by availableHyps()
*/
//================================================================================
void SMESHGUI_MeshOp::existingHyps( const int theDim,
_PTR(SObject) theFather,
QStringList& theHyps,
THypList& theHypList,
- HypothesisData* theAlgoData)
+ HypothesisData* theAlgoData) const
{
// Clear hypoheses list
theHyps.clear();
if ( !theFather )
return;
- const bool isAux = ( theHypType == AddHyp );
-
_PTR(SObject) aHypRoot;
_PTR(GenericAttribute) anAttr;
_PTR(AttributeName) aName;
_PTR(AttributeIOR) anIOR;
- bool isMesh = !_CAST( SComponent, theFather );
+ const bool isMesh = !_CAST( SComponent, theFather );
int aPart = -1;
if ( isMesh )
aPart = theHypType == Algo ? SMESH::Tag_RefOnAppliedAlgorithms : SMESH::Tag_RefOnAppliedHypothesis;
else
aPart = theHypType == Algo ? SMESH::Tag_AlgorithmsRoot : SMESH::Tag_HypothesisRoot;
+ const bool isAux = ( theHypType >= AddHyp );
+ const bool allHyps = ( !isMesh && theHypType != Algo && theDim > -1);
+
if ( theFather->FindSubObject( aPart, aHypRoot ) )
{
_PTR(ChildIterator) anIter =
CORBA::String_var hypType = aHypVar->GetName();
HypothesisData* aData = SMESH::GetHypothesisData( hypType.in() );
if ( !aData) continue;
- if ( ( theDim == -1 || aData->Dim.contains( theDim ) ) &&
- ( isCompatible ( theAlgoData, aData, theHypType )) &&
- ( theHypType == Algo || isAux == aData->IsAuxOrNeedHyp ))
+ if (( theDim == -1 || aData->Dim.contains( theDim ) ) &&
+ ( isCompatible ( theAlgoData, aData, theHypType )) &&
+ ( theHypType == Algo || isAux == aData->IsAuxOrNeedHyp ) &&
+ ( !allHyps || myAvailableHypData[theDim][theHypType].count(aData) ))
{
std::string aHypName = aName->Value();
theHyps.append( aHypName.c_str() );
myDim = theDim;
myType = theType;
+
+ // get a unique hyp name
QStringList aHypNames;
TDim2Type2HypList::const_iterator aDimIter = myExistingHyps.begin();
for ( ; aDimIter != myExistingHyps.end(); aDimIter++) {
// 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
{
if ( !isAccessibleDim( dim ))
continue;
- for ( int type = MainHyp; type < NbHypTypes; type++ )
+
+ // get indices of selected hyps
+ const int nbTypes = nbDlgHypTypes(dim);
+ std::vector<int> hypIndexByType( nbTypes, -1 );
+ for ( int dlgType = MainHyp; dlgType < nbTypes; dlgType++ )
{
+ hypIndexByType[ dlgType ] = currentHyp( dim, dlgType );
+ }
+
+ // update hyps
+ for ( int dlgType = MainHyp; dlgType < nbTypes; dlgType++ )
+ {
+ const int type = Min( dlgType, AddHyp );
myAvailableHypData[ dim ][ type ].clear();
QStringList anAvailable, anExisting;
HypothesisData* curAlgo = algoByDim[ dim ];
- int hypIndex = currentHyp( dim, type );
+ int hypIndex = hypIndexByType[ dlgType ];
SMESH::SMESH_Hypothesis_var curHyp;
if ( hypIndex >= 0 && hypIndex < myExistingHyps[ dim ][ type ].count() )
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();
}
- existingHyps( dim, type, pObj, anExisting, myExistingHyps[ dim ][ type ], curAlgo);
availableHyps( dim, type, anAvailable, myAvailableHypData[ dim ][ type ], curAlgo);
+ existingHyps( dim, type, pObj, anExisting, myExistingHyps[ dim ][ type ], curAlgo);
defaulHypAvlbl = (type == MainHyp && !curAlgo->IsAuxOrNeedHyp );
}
// set list of hypotheses
- myDlg->tab( dim )->setAvailableHyps( type, anAvailable );
- myDlg->tab( dim )->setExistingHyps( type, anExisting, defaulHypAvlbl );
-
+ if ( dlgType <= AddHyp )
+ {
+ myDlg->tab( dim )->setAvailableHyps( type, anAvailable );
+ myDlg->tab( dim )->setExistingHyps( type, anExisting, defaulHypAvlbl );
+ }
// set current existing hypothesis
if ( !curHyp->_is_nil() && !anExisting.isEmpty() )
hypIndex = this->find( curHyp, myExistingHyps[ dim ][ type ]);
else
hypIndex = -1;
- if ( !isSubmesh && hypIndex < 0 && anExisting.count() == 1 ) {
+ if ( !isSubmesh && myToCreate && hypIndex < 0 && anExisting.count() == 1 ) {
// 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;
if ( algoByDim[ dim ] &&
- SMESH::IsAvailableHypothesis( algoByDim[ dim ], hypTypeName.in(), isOptional ) &&
- !isOptional )
+ SMESH::IsAvailableHypothesis( algoByDim[ dim ], hypTypeName.in(), isOptional ) &&
+ !isOptional )
hypIndex = 0;
}
- setCurrentHyp( dim, type, hypIndex );
+ setCurrentHyp( dim, dlgType, hypIndex );
}
}
}
SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ) );
}
- for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ ) {
+ for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ )
+ {
if ( !isAccessibleDim( aDim )) continue;
// assign hypotheses
- for ( int aHypType = MainHyp; aHypType <= AddHyp; aHypType++ ) {
- int aHypIndex = currentHyp( aDim, aHypType );
- if ( aHypIndex >= 0 && aHypIndex < myExistingHyps[ aDim ][ aHypType ].count() ) {
- SMESH::SMESH_Hypothesis_var aHypVar = myExistingHyps[ aDim ][ aHypType ][ aHypIndex ].first;
+ for ( int dlgType = MainHyp; dlgType < nbDlgHypTypes(aDim); dlgType++ )
+ {
+ const int aHypIndex = currentHyp( aDim, dlgType );
+ const int aHypType = Min( dlgType, AddHyp );
+ if ( aHypIndex >= 0 && aHypIndex < myExistingHyps[ aDim ][ aHypType ].count() )
+ {
+ SMESH::SMESH_Hypothesis_var aHypVar =
+ myExistingHyps[ aDim ][ aHypType ][ aHypIndex ].first;
if ( !aHypVar->_is_nil() )
SMESH::AddHypothesisOnMesh( aMeshVar, aHypVar );
}
if ( !anAlgoVar->_is_nil() )
SMESH::AddHypothesisOnSubMesh( aSubMeshVar, anAlgoVar );
// assign hypotheses
- for ( int aHypType = MainHyp; aHypType <= AddHyp; aHypType++ )
+ for ( int dlgType = MainHyp; dlgType < nbDlgHypTypes(aDim); dlgType++ )
{
- int aHypIndex = currentHyp( aDim, aHypType );
+ const int aHypIndex = currentHyp( aDim, dlgType );
+ const int aHypType = Min( dlgType, AddHyp );
if ( aHypIndex >= 0 && aHypIndex < myExistingHyps[ aDim ][ aHypType ].count() )
{
SMESH::SMESH_Hypothesis_var aHypVar =
return myDlg->tab( theDim )->currentHyp( theHypType ) - 1;
}
+//================================================================================
+/*!
+ * \brief Checks if a hypothesis is selected
+ */
+//================================================================================
+
+bool SMESHGUI_MeshOp::isSelectedHyp( int theDim, int theHypType, int theIndex) const
+{
+ if ( theHypType < AddHyp ) // only one hyp can be selected
+ return currentHyp( theDim, theHypType ) == theIndex;
+
+ for ( int dlgHypType = AddHyp; dlgHypType < nbDlgHypTypes( theDim ); ++dlgHypType )
+ if ( currentHyp( theDim, dlgHypType ) == theIndex )
+ return true;
+
+ return false;
+}
+
+//================================================================================
+/*!
+ * \brief Returns nb of HypType's taking into account possible several
+ * selected additional hypotheses which are coded as additional HypType's.
+ */
+//================================================================================
+
+int SMESHGUI_MeshOp::nbDlgHypTypes( const int dim ) const
+{
+ return NbHypTypes + myDlg->tab( dim )->nbAddHypTypes();
+}
+
//================================================================================
/*!
* \brief Returns true if hypotheses of given dim can be assigned
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
-// myAvailableHypData[ dim ][ Algo ].push_back( algoData );
-// aHypIndex = myAvailableHypData[ dim ][ hypType ].count() - 1;
-// }
+ // if ( aHypIndex < 0 && algoData ) {
+ // // assigned algo is incompatible with other algorithms
+ // myAvailableHypData[ dim ][ Algo ].push_back( algoData );
+ // aHypIndex = myAvailableHypData[ dim ][ hypType ].count() - 1;
+ // }
algoFound = ( aHypIndex > -1 );
}
setCurrentHyp( dim, Algo, aHypIndex );
{
// get hypotheses
existingHyps( dim, hypType, pObj, anExisting, myObjHyps[ dim ][ hypType ] );
- // find index of requered hypothesis among existing ones for this dimension and type
- int aHypIndex = -1;
- if ( myObjHyps[ dim ][ hypType ].count() > 0 ) {
- aHypIndex = find( myObjHyps[ dim ][ hypType ].first().first,
- myExistingHyps[ 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
+ int aHypIndex = find( myObjHyps[ dim ][ hypType ][ i ].first,
+ myExistingHyps[ dim ][ hypType ] );
if ( aHypIndex < 0 ) {
// assigned hypothesis is incompatible with the algorithm
if ( currentHyp( dim, Algo ) < 0 )
{ // none algo selected; it is edition for sure, of submesh maybe
hypWithoutAlgo = true;
- myExistingHyps[ dim ][ hypType ].push_back( myObjHyps[ dim ][ hypType ].first() );
+ myExistingHyps[ dim ][ hypType ].push_back( myObjHyps[ dim ][ hypType ][ i ] );
+ anExisting.push_back( myObjHyps[ dim ][ hypType ][ i ].second );
aHypIndex = myExistingHyps[ dim ][ hypType ].count() - 1;
myDlg->tab( dim )->setExistingHyps( hypType, anExisting );
}
}
+ setCurrentHyp( dim, hypType + i, aHypIndex );
+
+ if ( hypType == MainHyp ) break; // only one main hyp allowed
}
- setCurrentHyp( dim, hypType, aHypIndex );
}
}
// make available other hyps of same type as one without algo
//================================================================================
/*!
* \brief Gets name of object
- * \param theSO - SObject
- * \retval QString - name of object
+ * \param theSO - SObject
+ * \retval QString - name of object
*
* Gets name of object
*/
// 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 );
myObjHyps[ dim ][ Algo ].append( THypItem( anAlgoVar, aName) );
}
- // assign hypotheses
+ // remove deselected hypotheses
for ( int hypType = MainHyp; hypType <= AddHyp; hypType++ )
{
- int aNewHypIndex = currentHyp( dim, hypType );
- int anOldHypIndex = -1;
-
- // remove old hypotheses
- if ( myObjHyps[ dim ][ hypType ].count() > 0 )
+ for ( int i = 0, nb = myObjHyps[ dim ][ hypType ].count(); i < nb; ++i )
{
- anOldHypIndex = find( myObjHyps[ dim ][ hypType ].first().first,
- myExistingHyps[ dim ][ hypType ] );
- if ( aNewHypIndex != anOldHypIndex || // different hyps
- anOldHypIndex == -1 ) // hyps of different algos
+ SMESH::SMESH_Hypothesis_var hyp = myObjHyps[ dim ][ hypType ][ i ].first;
+ int hypIndex = this->find( hyp, myExistingHyps[ dim ][ hypType ]);
+ if ( !isSelectedHyp( dim, hypType, hypIndex ) && !hyp->_is_nil() )
{
- SMESH::RemoveHypothesisOrAlgorithmOnMesh
- ( pObj, myObjHyps[ dim ][ hypType ].first().first );
- myObjHyps[ dim ][ hypType ].clear();
+ SMESH::RemoveHypothesisOrAlgorithmOnMesh( pObj, hyp );
}
}
-
- // assign new hypotheses
- if ( aNewHypIndex != anOldHypIndex && aNewHypIndex > -1 )
+ }
+ // assign newly selected hypotheses
+ for ( int dlgType = MainHyp; dlgType < nbDlgHypTypes(dim); dlgType++ )
+ {
+ const int curIndex = currentHyp( dim, dlgType );
+ const int hypType = Min( dlgType, AddHyp );
+ if ( curIndex >= 0 && curIndex < myExistingHyps[ dim ][ hypType ].count() )
{
- if ( isMesh )
- SMESH::AddHypothesisOnMesh
- (aMeshVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
- else if ( !aSubMeshVar->_is_nil() )
- SMESH::AddHypothesisOnSubMesh
- ( aSubMeshVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
+ SMESH::SMESH_Hypothesis_var hyp = myExistingHyps[ dim ][ hypType ][ curIndex ].first;
+
+ bool isAssigned = ( this->find( hyp, myObjHyps[ dim ][ hypType ]) >= 0 );
+ if ( !isAssigned )
+ {
+ if ( isMesh )
+ SMESH::AddHypothesisOnMesh (aMeshVar, hyp );
+ else if ( !aSubMeshVar->_is_nil() )
+ SMESH::AddHypothesisOnSubMesh ( aSubMeshVar, hyp );
+ }
}
- // reread all hypotheses of mesh if necessary
+ // reread all hypotheses of mesh
QStringList anExisting;
existingHyps( dim, hypType, pObj, anExisting, myObjHyps[ dim ][ hypType ] );
}
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;
+}
+
