-// Copyright (C) 2007-2015 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
//================================================================================
void SMESHGUI_MeshOp::startOperation()
{
+ myIgnoreAlgoSelection = false;
+
if (!myDlg)
{
myDlg = new SMESHGUI_MeshDlg( myToCreate, myIsMesh );
}
}
SMESHGUI_SelectionOp::startOperation();
- // iterate through dimensions and get available algoritms, set them to the dialog
+ // iterate through dimensions and get available algorithms, set them to the dialog
_PTR(SComponent) aFather = SMESH::GetActiveStudyDocument()->FindComponent( "SMESH" );
for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ )
{
myDlg->setGeomPopupEnabled(false);
selectionDone();
- myIgnoreAlgoSelection = false;
myHasConcurrentSubBefore = false;
myObjectToSelect.clear();
{
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
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() ) {
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 ( thePrevAlgoData, aData, theHypType ) &&
isCompatible ( theNextAlgoData, aData, theHypType ) ) ||
- ( theMeshType == "ANY" && aData->InputTypes.isEmpty())) {
- if ( !theMeshType.isEmpty() && theDim >= SMESH::DIM_2D &&
+ ( theMeshType == "ANY" && aData->InputTypes.isEmpty()))
+ {
+ if ( ( !theMeshType.isEmpty() ) &&
+ ( theDim >= SMESH::DIM_2D ) &&
( ( theMeshType != "ANY" && !isCompatibleToMeshType( aData, theMeshType )) ||
- !isCompatibleToGeometry( aData, aCurrentGeomToSelect, aGeomVar )))
+ !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 )
+ if ( !theMeshType.isEmpty() && !aCurrentGeomToSelect.isEmpty() )
myLastGeomToSelect = aCurrentGeomToSelect;
}
// 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;
theCreator->setShapeEntry( aGeomEntry );
if ( aMeshEntry != "" )
theCreator->setMainShapeEntry( aMeshEntry );
+
+ theCreator->setNoGeomMesh( !myIsOnGeometry && myIsMesh && !myToCreate );
}
//================================================================================
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();
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 );
QStringList anAvailable;
- // check that tab enabled of one less dimension
- if ( aDim > SMESH::DIM_0D )
- {
- 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 {
- myDlg->enableTab( i );
- }
+ // 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 );
}
}
}
nextAlgo = 0;
}
- // set new available algoritms
+ // set new available algorithms
availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], prevAlgo, nextAlgo, anCurrentCompareType);
HypothesisData* soleCompatible = 0;
if ( anAvailable.count() == 1 )
algoIndex = myAvailableHypData[dim][Algo].indexOf( curAlgo );
if ( !isSubmesh && algoIndex < 0 && soleCompatible && !forward && dim != SMESH::DIM_0D) {
// select the sole compatible algo
- algoIndex = myAvailableHypData[dim][Algo].indexOf( soleCompatible );
+ algoIndex = 0;
}
- setCurrentHyp( dim, Algo, algoIndex);
+ 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;
a3DAlgo = prevAlgo;
continue;
}
- }
+ } // loops backward and forward
+
- // set hypotheses corresponding to the found algoritms
+ // set hypotheses corresponding to the found algorithms
_PTR(SObject) pObj = SMESH::GetActiveStudyDocument()->FindComponent("SMESH");
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;
* \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 );
+ }
}
//================================================================================
return anAlgoVar;
QString aHypName = dataList[ aHypIndex ]->TypeName;
- // get existing algoritms
+ // get existing algorithms
_PTR(SObject) pObj = SMESH::GetActiveStudyDocument()->FindComponent("SMESH");
QStringList tmp;
existingHyps( theDim, Algo, pObj, tmp, myExistingHyps[ theDim ][ Algo ]);
SMESH::CreateHypothesis(aHypName, aHypName, true);
aHyp.out();
}
+ delete aCreator;
}
QStringList tmpList;
_PTR(SComponent) aFather = SMESH::GetActiveStudyDocument()->FindComponent( "SMESH" );
// 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 );
* \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);
}
}
else
for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
- if ( i > myMaxShapeDim || ( isReqDisBound && i != aReqDim ) ) myDlg->disableTab( i );
- else myDlg->enableTab( i );
+ if ( i > myMaxShapeDim || ( isReqDisBound && i < aReqDim ) ) myDlg->disableTab( i );
+ else myDlg->enableTab( i );
}
myDlg->setCurrentTab( theTabIndex );
}
else
{
- HypothesisData* anCurrentAlgo;
+ HypothesisData* anCurrentAlgo = 0;
bool isReqDisBound = true;
QString anCurrentCompareType = anCompareType;
isNone = currentHyp( aDim, Algo ) < 0;
//set new algorithm list and select the current algorithm
myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
anCurrentCompareType = ( anCompareType == "HEXA" || anCompareType == "QUAD" ) ? "QUAD" : "TRIA";
- setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
+ setCurrentHyp( dim, Algo, anCurrentAvailableAlgo, /*updateHyps=*/true );
}
- 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-- ) {
+ 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 ( 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;
}
+ else {
+ myDlg->enableTab( i );
+ }
+ }
+ if ( aDim == SMESH::DIM_2D) {
+ setCurrentHyp( SMESH::DIM_3D, Algo, -1, /*updateHyps=*/true );
+ myDlg->disableTab( SMESH::DIM_3D );
}
+
int currentTab = ( theTabIndex <= aDim ) ? theTabIndex : aDim;
myDlg->setCurrentTab( currentTab );
}
