-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2014 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
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include <GEOMBase.h>
#include <GeometryGUI.h>
#include <GEOM_wrap.hxx>
+#include <GEOMImpl_Types.hxx>
// SALOME GUI includes
#include <SalomeApp_Tools.h>
// Qt includes
#include <QStringList>
#include <QLineEdit>
+#include <QApplication>
// OCCT includes
#include <TopoDS.hxx>
#include <SALOMEconfig.h>
#include CORBA_CLIENT_HEADER(SMESH_Gen)
-//To disable automatic genericobj management, the following line should be commented.
-//Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
-#define WITHGENERICOBJ
-
//================================================================================
/*!
* \brief Constructor
if ( GeometryGUI::GetGeomGen()->_is_nil() )// check that GEOM_Gen exists
GeometryGUI::InitGeomGen();
myIsOnGeometry = true;
+ myMaxShapeDim = -1;
}
//================================================================================
}
connect( myDlg, SIGNAL( hypoSet( const QString& )), SLOT( onHypoSet( const QString& )));
connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool )));
-
- if ( myToCreate )
+ 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";
- else myHelpFileName = "editing_meshes_page.html";
+ else myHelpFileName = "constructing_submeshes_page.html";
+ }
+ else {
+ myHelpFileName = "editing_meshes_page.html";
+ }
}
SMESHGUI_SelectionOp::startOperation();
-
// iterate through dimensions and get available algoritms, set them to the dialog
_PTR(SComponent) aFather = SMESH::GetActiveStudyDocument()->FindComponent( "SMESH" );
for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ )
myDlg->activateObject( SMESHGUI_MeshDlg::Obj );
myDlg->setCurrentTab( SMESH::DIM_3D );
+
+ QStringList TypeMeshList;
+ createMeshTypeList( TypeMeshList );
+ setAvailableMeshType( TypeMeshList );
+
myDlg->show();
myDlg->setGeomPopupEnabled(false);
selectionDone();
myIgnoreAlgoSelection = false;
+ myHasConcurrentSubBefore = false;
myObjectToSelect.clear();
}
onAlgoSelected(-1, i);
}
myDlg->setMaxHypoDim( shapeDim );
+ myMaxShapeDim = shapeDim;
myDlg->setHypoSets( SMESH::GetHypothesesSets( shapeDim ));
if (!myToCreate) // edition: read hypotheses
{
if (pObj != 0)
{
- SMESH::SMESH_subMesh_var aVar =
+ SMESH::SMESH_subMesh_var submeshVar =
SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() );
- myDlg->setObjectShown( SMESHGUI_MeshDlg::Mesh, !aVar->_is_nil() );
+ 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();
readMesh();
+ myIsMesh = submeshVar->_is_nil();
}
else
myDlg->reset();
for (int i = SMESH::DIM_0D;i < SMESH::DIM_3D; ++i) {
myDlg->disableTab(i);
}
- //Hide labels and fields (Mesh ang Geometry)
+ myMaxShapeDim = -1;
+ //Hide labels and fields (Mesh and Geometry)
myDlg->setObjectShown( SMESHGUI_MeshDlg::Mesh, false );
myDlg->setObjectShown( SMESHGUI_MeshDlg::Geom, false );
myDlg->adjustSize();
readMesh();
}
+ int curIndex = myDlg->currentMeshType( );
+ QStringList TypeMeshList;
+ createMeshTypeList( TypeMeshList );
+ setAvailableMeshType( TypeMeshList );
+ curIndex =( curIndex >= TypeMeshList.count() ) ? 0 : curIndex;
+ myDlg->setCurrentMeshType( curIndex );
+ setFilteredAlgoData( myMaxShapeDim, curIndex);
}
catch ( const SALOME::SALOME_Exception& S_ex )
{
if ( myToCreate )
{
QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- if ( aGeomEntry == "" )
+ if ( aGeomEntry.isEmpty() )
{
- theMess = tr( "GEOMETRY_OBJECT_IS_NOT_DEFINED" );
- return false;
+ theMess = tr( myIsMesh ?
+ "GEOMETRY_OBJECT_IS_NOT_DEFINED_MESH" :
+ "GEOMETRY_OBJECT_IS_NOT_DEFINED_SUBMESH");
+ if ( !myIsMesh )
+ return false;
+ dlg()->show();
+ if ( SUIT_MessageBox::warning( myDlg, tr( "SMESH_WRN_WARNING" ), theMess,
+ SUIT_MessageBox::Yes, SUIT_MessageBox::No ) == SUIT_MessageBox::No )
+ {
+ theMess = "";
+ return false;
+ }
+ return true;
}
_PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() );
if ( !pGeom || GEOM::GEOM_Object::_narrow( _CAST( SObject,pGeom )->GetObject() )->_is_nil() )
theHyps.clear();
bool isAlgo = ( theHypType == Algo );
bool isAux = ( theHypType == AddHyp );
- QStringList aHypTypeNameList = SMESH::GetAvailableHypotheses( isAlgo, theDim, isAux, myIsOnGeometry );
+ QStringList aHypTypeNameList = SMESH::GetAvailableHypotheses( isAlgo, theDim, isAux, myIsOnGeometry, !myIsMesh );
QStringList::const_iterator anIter;
for ( anIter = aHypTypeNameList.begin(); anIter != aHypTypeNameList.end(); ++anIter )
//================================================================================
/*!
* \brief Gets existing hypotheses or algorithms
- * \param theDim - specifies dimension of returned hypotheses/algorifms
- * \param theHypType - specifies whether algorims or hypotheses or additional ones
- * are retrieved (possible values are in HypType enumeration)
- * \param theFather - start object for finding ( may be component, mesh, or sub-mesh )
- * \param theHyps - output list of names.
- * \param theHypVars - output list of variables.
- * \param theAlgoData - to select hypos able to be used by this algo (optional)
+ * \param theDim - specifies dimension of returned hypotheses/algorifms
+ * \param theHypType - specifies whether algorims or hypotheses or additional ones
+ * are retrieved (possible values are in HypType enumeration)
+ * \param theFather - start object for finding ( may be component, mesh, or sub-mesh )
+ * \param theHyps - output list of names.
+ * \param theHypVars - output list of variables.
+ * \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
*/
//================================================================================
-void SMESHGUI_MeshOp::existingHyps( const int theDim,
- const int theHypType,
- _PTR(SObject) theFather,
- QStringList& theHyps,
- THypList& theHypList,
+void SMESHGUI_MeshOp::existingHyps( const int theDim,
+ const int theHypType,
+ _PTR(SObject) theFather,
+ QStringList& theHyps,
+ THypList& theHypList,
HypothesisData* theAlgoData)
{
// Clear hypoheses list
if ( !aData) continue;
if ( ( theDim == -1 || aData->Dim.contains( theDim ) ) &&
( isCompatible ( theAlgoData, aData, theHypType )) &&
- ( isAux == aData->IsAux ))
+ ( theHypType == Algo || isAux == aData->IsAuxOrNeedHyp ))
{
std::string aHypName = aName->Value();
theHyps.append( aHypName.c_str() );
// Call hypothesis creation server method (without GUI)
SMESH::SMESH_Hypothesis_var aHyp =
SMESH::CreateHypothesis(theTypeName, aHypName, false);
-#ifdef WITHGENERICOBJ
- if (!CORBA::is_nil(aHyp))
- aHyp->UnRegister();
-#endif
- } else {
+ aHyp.out();
+ }
+ else {
// Get hypotheses creator client (GUI)
- // BUG 0020378
- //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(theTypeName);
SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(theTypeName);
// Create hypothesis
else {
SMESH::SMESH_Hypothesis_var aHyp =
SMESH::CreateHypothesis(theTypeName, aHypName, false);
-#ifdef WITHGENERICOBJ
- if (!CORBA::is_nil(aHyp))
- aHyp->UnRegister();
-#endif
+ aHyp.out();
}
}
algoByDim[ aDim ] = algoData;
QStringList anAvailable;
- if ( !algoData ) { // all algos becomes available
- availableHyps( aDim, Algo, anAvailable, myAvailableHypData[ aDim ][ Algo ]);
- myDlg->tab( aDim )->setAvailableHyps( Algo, 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
-
- // 2 loops: backward and forward from algo dimension
+ 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 );
+ }
+ }
+ myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable );
+ }
+ // 2 loops: backward and forward from algo dimension
for ( int forward = false; forward <= true; ++forward )
{
int dim = aDim + 1, lastDim = SMESH::DIM_3D, dir = 1;
curAlgo = 0;
}
// set new available algoritms
- availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], prevAlgo );
+ 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 );
+ }
+ }
+ }
HypothesisData* soleCompatible = 0;
if ( anAvailable.count() == 1 )
soleCompatible = myAvailableHypData[dim][Algo][0];
- if ( dim == aTopDim && prevAlgo ) // all available algoritms should be selectable any way
- availableHyps( dim, Algo, anAvailable, 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();
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 );
+ setCurrentHyp( dim, Algo, algoIndex);
// remember current algo
prevAlgo = algoByDim[ dim ] = hypData( dim, Algo, algoIndex );
bool algoDeselectedByUser = ( theDim < 0 && aDim == dim );
CORBA::String_var curHypType = curHyp->GetName();
if ( !algoDeselectedByUser &&
- myObjHyps[ dim ][ type ].count() > 0 &&
- !strcmp( curHypType, myObjHyps[ dim ][ type ].first().first->GetName()) )
+ myObjHyps[ dim ][ type ].count() > 0 &&
+ !strcmp( curHypType, myObjHyps[ dim ][ type ].first().first->GetName()) )
{
HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() );
for (int i = 0; i < myAvailableHypData[ dim ][ Algo ].count(); ++i) {
}
}
// get hyps compatible with curAlgo
+ bool defaulHypAvlbl = false;
if ( curAlgo )
{
// check if a selected hyp is compatible with the curAlgo
}
existingHyps( dim, type, pObj, anExisting, myExistingHyps[ dim ][ type ], curAlgo);
availableHyps( dim, type, anAvailable, myAvailableHypData[ dim ][ type ], curAlgo);
+ defaulHypAvlbl = (type == MainHyp && !curAlgo->IsAuxOrNeedHyp );
}
// set list of hypotheses
myDlg->tab( dim )->setAvailableHyps( type, anAvailable );
- myDlg->tab( dim )->setExistingHyps( type, anExisting );
+ myDlg->tab( dim )->setExistingHyps( type, anExisting, defaulHypAvlbl );
// set current existing hypothesis
if ( !curHyp->_is_nil() && !anExisting.isEmpty() )
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 );
{
theMess = "";
- //QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
- //QString aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
-
QStringList aList;
myDlg->selectedObject( SMESHGUI_MeshDlg::Geom, aList );
+ if ( aList.isEmpty() )
+ {
+ SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
+ if ( aSMESHGen->_is_nil() )
+ return false;
+
+ SMESH::SMESH_Mesh_var aMeshVar= aSMESHGen->CreateEmptyMesh();
+ if ( aMeshVar->_is_nil() )
+ return false;
+
+ _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar.in() );
+ if ( aMeshSO ) {
+ SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ) );
+ theEntryList.append( aMeshSO->GetID().c_str() );
+ }
+ return true;
+ }
+ QString namePrefix;
+ if ( aList.count() > 1 )
+ {
+ namePrefix = myDlg->objectText( SMESHGUI_MeshDlg::Obj );
+ int i = namePrefix.length() - 1;
+ while ( i > 0 && namePrefix[i].isDigit() )
+ --i;
+ if ( i < namePrefix.length() - 1 )
+ namePrefix.chop( namePrefix.length() - 1 - i );
+ else
+ namePrefix += "_";
+ }
QStringList::Iterator it = aList.begin();
- for ( ; it!=aList.end(); it++)
+ for ( int i = 0; it!=aList.end(); it++, ++i )
{
QString aGeomEntry = *it;
_PTR(SObject) pGeom = studyDS()->FindObjectID( aGeomEntry.toLatin1().data() );
return false;
_PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar.in() );
if ( aMeshSO ) {
- SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ) );
theEntryList.append( aMeshSO->GetID().c_str() );
+ if ( i > 0 ) setDefaultName( namePrefix );
+ SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ) );
}
for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ ) {
if ( !anAlgoVar->_is_nil() )
SMESH::AddHypothesisOnMesh( aMeshVar, anAlgoVar );
}
-#ifdef WITHGENERICOBJ
- // obj has been published in study. Its refcount has been incremented.
- // It is safe to decrement its refcount
- // so that it will be destroyed when the entry in study will be removed
- if (aMeshSO)
- aMeshVar->UnRegister();
-#endif
}
return true;
}
GEOM::GEOM_Object_wrap aGroupVar = op->CreateGroup(mainGeom, aGroupType);
op->UnionList(aGroupVar, aSeq);
- if (op->IsDone()) {
- aGeomVar = aGroupVar.in();
+ if (op->IsDone())
+ {
+ aGeomVar = GEOM::GEOM_Object::_duplicate( aGroupVar.in() );
// publish the GEOM group in study
QString aNewGeomGroupName ("Auto_group_for_");
selectObject( _PTR(SObject)() );
selectionDone();
+ checkSubMeshConcurrency( aMeshVar, aSubMeshVar, /*askUser=*/true );
+
return true;
}
* Generates and sets default mesh/submesh name(Mesh_1, Mesh_2, etc.)
*/
//================================================================================
-void SMESHGUI_MeshOp::setDefaultName() const
+void SMESHGUI_MeshOp::setDefaultName( const QString& thePrefix ) const
{
QString aResName;
_PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
int i = 1;
- QString aPrefix = tr( myIsMesh ? "SMESH_OBJECT_MESH" : "SMESH_SUBMESH" ) + "_";
+
+ QString aPrefix = thePrefix;
+ if ( aPrefix.isEmpty() )
+ aPrefix = tr( myIsMesh ? "SMESH_OBJECT_MESH" : "SMESH_SUBMESH" ) + "_";
+
_PTR(SObject) anObj;
do
{
if (aHypData)
{
QString aClientLibName = aHypData->ClientLibName;
- if (aClientLibName == "")
+ if ( aClientLibName.isEmpty() )
{
// Call hypothesis creation server method (without GUI)
SMESH::SMESH_Hypothesis_var aHyp =
SMESH::CreateHypothesis(aHypName, aHypName, true);
-#ifdef WITHGENERICOBJ
- if (!CORBA::is_nil(aHyp))
- aHyp->UnRegister();
-#endif
+ aHyp.out();
}
else
{
// Get hypotheses creator client (GUI)
- // BUG 0020378
SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypName);
// Create algorithm
if (aCreator)
- aCreator->create(true, aHypName, myDlg, 0, QString::null );
+ aCreator->create( true, aHypName, myDlg, 0, QString::null );
else {
SMESH::SMESH_Hypothesis_var aHyp =
SMESH::CreateHypothesis(aHypName, aHypName, true);
-#ifdef WITHGENERICOBJ
- if (!CORBA::is_nil(aHyp))
- aHyp->UnRegister();
-#endif
+ aHyp.out();
}
}
QStringList tmpList;
//================================================================================
/*!
- * \brief Reads parameters of an edited mesh and assigns them to the dialog
+ * \brief Reads parameters of an edited mesh/sub-mesh and assigns them to the dialog
*
* Called when mesh is edited only.
*/
QString aMeshName = name( aMeshSO );
myDlg->setObjectText( SMESHGUI_MeshDlg::Mesh, aMeshName );
}
+ myHasConcurrentSubBefore = checkSubMeshConcurrency( aMeshVar, aSubMeshVar );
}
// Get name of geometry object
- GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
- if ( !aGeomVar->_is_nil() )
- {
- _PTR(SObject) aGeomSO = studyDS()->FindObjectID( aGeomVar->GetStudyEntry() );
- QString aShapeName = name( aGeomSO );
- myDlg->setObjectText( SMESHGUI_MeshDlg::Geom, aShapeName );
- }
+ CORBA::String_var name = SMESH::GetGeomName( pObj );
+ if ( name.in() )
+ myDlg->setObjectText( SMESHGUI_MeshDlg::Geom, name.in() );
}
// Get hypotheses and algorithms assigned to the mesh/sub-mesh
QStringList anExisting;
const int lastDim = ( myIsOnGeometry ) ? SMESH::DIM_0D : SMESH::DIM_3D;
+ bool algoFound = false;
for ( int dim = SMESH::DIM_3D; dim >= lastDim; --dim )
{
// get algorithm
// myAvailableHypData[ dim ][ Algo ].push_back( algoData );
// aHypIndex = myAvailableHypData[ dim ][ hypType ].count() - 1;
// }
+ algoFound = ( aHypIndex > -1 );
}
setCurrentHyp( dim, Algo, aHypIndex );
// set existing and available hypothesis according to the selected algo
- onAlgoSelected( aHypIndex, dim );
+ if ( aHypIndex > -1 || !algoFound )
+ onAlgoSelected( aHypIndex, dim );
}
// get hypotheses
}
}
+ SALOMEDS_SObject* aSObject = _CAST(SObject, pObj);
+ CORBA::Object_var anObject = aSObject->GetObject();
+ SMESH::SMESH_Mesh_var aMeshVar = SMESH::SMESH_Mesh::_narrow( anObject );
+ SMESH::SMESH_subMesh_var aSubMeshVar = SMESH::SMESH_subMesh::_narrow( anObject );
+ bool isMesh = !aMeshVar->_is_nil();
+ if ( !isMesh && !aSubMeshVar->_is_nil() )
+ aMeshVar = aSubMeshVar->GetFather();
+
// Assign new algorithms and hypotheses
for ( int dim = aDim; dim <= SMESH::DIM_3D; dim++ )
{
if ( !anAlgoVar->_is_nil() && // some algo selected and
myObjHyps[ dim ][ Algo ].count() == 0 ) // no algo assigned
{
- SALOMEDS_SObject* aSObject = _CAST(SObject, pObj);
- CORBA::Object_var anObject = aSObject->GetObject();
- SMESH::SMESH_Mesh_var aMeshVar = SMESH::SMESH_Mesh::_narrow( anObject );
- bool isMesh = !aMeshVar->_is_nil();
- if ( isMesh ) {
+ if ( isMesh )
SMESH::AddHypothesisOnMesh( aMeshVar, anAlgoVar );
- } else {
- SMESH::SMESH_subMesh_var aVar =
- SMESH::SMESH_subMesh::_narrow( _CAST(SObject,pObj)->GetObject() );
- if ( !aVar->_is_nil() )
- SMESH::AddHypothesisOnSubMesh( aVar, anAlgoVar );
- }
+ else if ( !aSubMeshVar->_is_nil() )
+ SMESH::AddHypothesisOnSubMesh( aSubMeshVar, anAlgoVar );
+
myObjHyps[ dim ][ Algo ].append( THypItem( anAlgoVar, aName) );
}
}
// assign new hypotheses
- if ( aNewHypIndex != anOldHypIndex && aNewHypIndex != -1 )
+ if ( aNewHypIndex != anOldHypIndex && aNewHypIndex > -1 )
{
- SMESH::SMESH_Mesh_var aMeshVar =
- SMESH::SMESH_Mesh::_narrow( _CAST(SObject,pObj)->GetObject() );
- bool isMesh = !aMeshVar->_is_nil();
if ( isMesh )
- {
SMESH::AddHypothesisOnMesh
(aMeshVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
- }
- else
- {
- SMESH::SMESH_subMesh_var aVar =
- SMESH::SMESH_subMesh::_narrow( _CAST(SObject,pObj)->GetObject() );
- if ( !aVar->_is_nil() )
- SMESH::AddHypothesisOnSubMesh
- ( aVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
- }
+ else if ( !aSubMeshVar->_is_nil() )
+ SMESH::AddHypothesisOnSubMesh
+ ( aSubMeshVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
}
// reread all hypotheses of mesh if necessary
QStringList anExisting;
}
}
+ myHasConcurrentSubBefore =
+ checkSubMeshConcurrency( aMeshVar, aSubMeshVar, /*askUser=*/!myHasConcurrentSubBefore );
+
return true;
}
+//================================================================================
+/*!
+ * \brief Checks if a concurrent sub-meshes appear as result of sub-mesh
+ * creation/edition and, if (askUser) , proposes the uses to set up a desired
+ * order of sub-mesh computation.
+ * Returns \c true if a sub-mesh concurrency detected.
+ */
+//================================================================================
+
+bool SMESHGUI_MeshOp::checkSubMeshConcurrency(SMESH::SMESH_Mesh_ptr mesh,
+ SMESH::SMESH_subMesh_ptr submesh,
+ bool askUser)
+{
+ if ( CORBA::is_nil( mesh ) || CORBA::is_nil( submesh ))
+ return false;
+
+ bool isNewConcurrent = mesh->IsUnorderedSubMesh( submesh->GetId() );
+ if ( isNewConcurrent && askUser )
+ {
+ int butID = SUIT_MessageBox::warning( myDlg->parentWidget(), tr( "SMESH_WARNING" ),
+ tr("CONCURRENT_SUBMESH_APPEARS"),
+ tr("SMESH_BUT_YES"), tr("SMESH_BUT_NO"));
+ if ( butID == 0 )
+ {
+ _PTR(SObject) meshSO = SMESH::FindSObject( mesh );
+ LightApp_SelectionMgr* aSelectionMgr = selectionMgr();
+ if ( meshSO && aSelectionMgr )
+ {
+ myDlg->setEnabled( false ); // disactivate selection
+ selectionMgr()->clearFilters();
+ selectObject( meshSO );
+ SMESHGUI::GetSMESHGUI()->OnGUIEvent( 713 ); // MESH_ORDER
+ qApp->processEvents();
+
+ myDlg->setEnabled( true );
+ int obj = myDlg->getActiveObject();
+ onActivateObject( obj ); // restore filter
+ if ( !myToCreate )
+ {
+ selectObject( SMESH::FindSObject( submesh ));
+ selectionDone();
+ }
+ }
+ }
+ }
+
+ return isNewConcurrent;
+}
+
//================================================================================
/*!
* \brief Verifies whether given operator is valid for this one
sm->setSelectedObjects( anIOList, false );
}
}
+//================================================================================
+/*!
+ * \brief Create available list types of mesh
+ * \param theTypeMesh - Output list of available types of mesh
+ */
+//================================================================================
+void SMESHGUI_MeshOp::createMeshTypeList( QStringList& theTypeMesh)
+{
+ theTypeMesh.clear();
+ theTypeMesh.append( tr( "MT_ANY" ) );
+ if ( myMaxShapeDim >= 2 || myMaxShapeDim == -1 )
+ {
+ theTypeMesh.append( tr( "MT_TRIANGULAR" ) );
+ theTypeMesh.append( tr( "MT_QUADRILATERAL" ) );
+ }
+ if ( myMaxShapeDim == 3 || myMaxShapeDim == -1 )
+ {
+ theTypeMesh.append( tr( "MT_TETRAHEDRAL" ) );
+ theTypeMesh.append( tr( "MT_HEXAHEDRAL" ) );
+ }
+
+}
+//================================================================================
+/*!
+ * \brief Set available types of mesh
+ * \param theTypeMesh - List of available types of mesh
+ */
+//================================================================================
+void SMESHGUI_MeshOp::setAvailableMeshType( const QStringList& theTypeMesh )
+{
+ myDlg->setAvailableMeshType( theTypeMesh );
+}
+
+//================================================================================
+/*!
+ * \brief SLOT. Is called when the user select type of mesh
+ * \param theTabIndex - Index of current active tab
+ * \param theIndex - Index of current type of mesh
+ */
+//================================================================================
+void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex)
+{
+ setFilteredAlgoData( theTabIndex, theIndex);
+}
+
+//================================================================================
+/*!
+ * \brief Set a filtered list of available algorithms by mesh type
+ * \param theTabIndex - Index of current active tab
+ * \param theIndex - Index of current type of mesh
+ */
+//================================================================================
+void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theIndex)
+{
+ int aDim;
+ THypDataList anAvailableAlgsData;
+ QStringList anAvailableAlgs;
+ QString anCompareType = "";
+ bool isAvailableChoiceAlgo = false;
+ int anCurrentAvailableAlgo = 0;
+ 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:
+ 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" )
+ {
+ for ( int dim = SMESH::DIM_3D; dim >= SMESH::DIM_2D; dim-- )
+ {
+ 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;
+ 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 );
+ }
+ }
+ myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
+ if ( isAvailableChoiceAlgo )
+ setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
+ }
+ 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 );
+ }
+ else
+ for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
+ if ( i > myMaxShapeDim ) myDlg->disableTab( i );
+ else myDlg->enableTab( i );
+ }
+ myDlg->setCurrentTab( theTabIndex );
+ }
+ else
+ {
+ QString anCurrentAlgo;
+ bool isReqDisBound = true;
+ QString anCurrentCompareType = anCompareType;
+ isNone = currentHyp( aDim, Algo ) < 0;
+ if ( !isNone && !myAvailableHypData[aDim][Algo].empty() &&
+ myAvailableHypData[aDim][Algo].count() != anAvailableAlgsData.count() )
+ 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 );
+ // 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 ;
+ }
+ }
+ //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 );
+ }
+
+ 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--){
+ myDlg->disableTab( j );
+ setCurrentHyp( j , Algo, -1 );
+ }
+ break;
+ }
+ }
+ }
+ myDlg->enableTab( aDim );
+ myDlg->setCurrentTab( aDim );
+ }
+ QStringList aHypothesesSetsList = SMESH::GetHypothesesSets( aDim );
+ QStringList aFilteredHypothesesSetsList;
+ aFilteredHypothesesSetsList.clear();
+ QStringList::const_iterator inHypoSetName = aHypothesesSetsList.begin();
+ for ( ; inHypoSetName != aHypothesesSetsList.end(); ++inHypoSetName )
+ {
+ HypothesesSet* currentHypoSet = SMESH::GetHypothesesSet( *inHypoSetName );
+ bool isAvailable = false;
+ currentHypoSet->init( true );
+ 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 i = 0 ; i < anAvailableAlgsData.count(); i++ )
+ {
+ HypothesisData* aCurAlgo = anAvailableAlgsData.at( i );
+ 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 ( isAvailable ) break;
+ }
+ if ( !isAvailable ) break;
+ }
+ }
+ if ( isAvailable )
+ aFilteredHypothesesSetsList.append( *inHypoSetName );
+ }
+ myDlg->setHypoSets( aFilteredHypothesesSetsList );
+}
