-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2020 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 "SMESHGUI_HypothesesUtils.h"
#include "SMESHGUI.h"
+#include "SMESHGUI_GEOMGenUtils.h"
#include "SMESHGUI_Hypotheses.h"
-#include "SMESHGUI_XmlHandler.h"
#include "SMESHGUI_Utils.h"
-#include "SMESHGUI_GEOMGenUtils.h"
+#include "SMESHGUI_VTKUtils.h"
+#include "SMESHGUI_XmlHandler.h"
+
+#include "SMESH_Actor.h"
// SALOME GUI includes
#include <SUIT_Desktop.h>
#include <string>
// Qt includes
-#include <QMap>
#include <QDir>
-//#include <QList>
// Other includes
#endif
#ifdef WIN32
-#define LibHandle HMODULE
-#define LoadLib( name ) LoadLibrary( name )
-#define GetProc GetProcAddress
-#define UnLoadLib( handle ) FreeLibrary( handle );
-#else
-#define LibHandle void*
-#define LoadLib( name ) dlopen( name, RTLD_LAZY )
-#define GetProc dlsym
-#define UnLoadLib( handle ) dlclose( handle );
-#endif
+ #define LibHandle HMODULE
+ #define LoadLib( name ) LoadLibrary( name )
+ #define GetProc GetProcAddress
+ #define UnLoadLib( handle ) FreeLibrary( handle );
+ #define env_sep ";"
+#else // WIN32
+ #define LibHandle void*
+ #ifdef DYNLOAD_LOCAL
+ #define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_LOCAL )
+ #else // DYNLOAD_LOCAL
+ #define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_GLOBAL )
+ #endif // DYNLOAD_LOCAL
+ #define GetProc dlsym
+ #define UnLoadLib( handle ) dlclose( handle );
+ #define env_sep ":"
+#endif // WIN32
#ifdef _DEBUG_
-static int MYDEBUG = 1;
+static int MYDEBUG = 0;
#else
static int MYDEBUG = 0;
#endif
typedef IMap<QString,HypothesisData*> THypothesisDataMap;
THypothesisDataMap myHypothesesMap;
THypothesisDataMap myAlgorithmsMap;
-
+
// BUG 0020378
//typedef QMap<QString,SMESHGUI_GenericHypothesisCreator*> THypCreatorMap;
//THypCreatorMap myHypCreatorMap;
QList<HypothesesSet*> myListOfHypothesesSets;
- void processHypothesisStatus(const int theHypStatus,
+ void processHypothesisStatus(const int theHypStatus,
SMESH::SMESH_Hypothesis_ptr theHyp,
- const bool theIsAddition)
+ const bool theIsAddition,
+ const char* theError = 0)
{
if (theHypStatus > SMESH::HYP_OK) {
// get Hyp name
QString aHypName ("NULL Hypothesis");
if (!CORBA::is_nil(theHyp)) {
_PTR(SObject) Shyp = SMESH::FindSObject(theHyp);
- if (Shyp)
+ if (Shyp) {
// name in study
aHypName = Shyp->GetName().c_str();
- else
+ }
+ else {
// label in xml file
- aHypName = GetHypothesisData(theHyp->GetName())->Label;
+ CORBA::String_var hypType = theHyp->GetName();
+ aHypName = GetHypothesisData( hypType.in() )->Label;
+ }
}
// message
else
aMsg = (isFatal ? "SMESH_CANT_RM_HYP" : "SMESH_RM_HYP_WRN");
- aMsg = QObject::tr(aMsg.toLatin1().data()).arg(aHypName) +
- QObject::tr(QString("SMESH_HYP_%1").arg(theHypStatus).toLatin1().data());
+ aMsg = QObject::tr(aMsg.toLatin1().data()).arg(aHypName);
- if ( theHypStatus == SMESH::HYP_HIDDEN_ALGO ) // PAL18501
- aMsg = aMsg.arg( GetHypothesisData(theHyp->GetName())->Dim[0] );
+ if ( theError && theError[0] )
+ {
+ aMsg += theError;
+ }
+ else
+ {
+ aMsg += QObject::tr(QString("SMESH_HYP_%1").arg(theHypStatus).toLatin1().data());
+ if ( theHypStatus == SMESH::HYP_HIDDEN_ALGO ) { // PAL18501
+ CORBA::String_var hypType = theHyp->GetName();
+ if ( HypothesisData* hd = GetHypothesisData( hypType.in() ))
+ aMsg = aMsg.arg( hd->Dim[0] );
+ }
+ }
SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
aMsg);
void InitAvailableHypotheses()
{
SUIT_OverrideCursor wc;
- if (myHypothesesMap.empty() && myAlgorithmsMap.empty()) {
+ if ( myHypothesesMap.empty() && myAlgorithmsMap.empty() )
+ {
// Resource manager
SUIT_ResourceMgr* resMgr = SMESHGUI::resourceMgr();
if (!resMgr) return;
if (cenv)
HypsXml.sprintf("%s", cenv);
- QStringList HypsXmlList = HypsXml.split(":", QString::SkipEmptyParts);
+ QStringList HypsXmlList = HypsXml.split(env_sep, QString::SkipEmptyParts);
if (HypsXmlList.count() == 0) {
SUIT_MessageBox::critical(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
if (ok) {
THypothesisDataMap::ConstIterator it1 = aXmlHandler->myHypothesesMap.begin();
-
+
for( ;it1 != aXmlHandler->myHypothesesMap.end(); it1++)
myHypothesesMap.insert( it1.key(), it1.value() );
-
+
it1 = aXmlHandler->myAlgorithmsMap.begin();
for( ;it1 != aXmlHandler->myAlgorithmsMap.end(); it1++)
myAlgorithmsMap.insert( it1.key(), it1.value() );
-
+
QList<HypothesesSet*>::iterator it;
- for ( it = aXmlHandler->myListOfHypothesesSets.begin();
+ for ( it = aXmlHandler->myListOfHypothesesSets.begin();
it != aXmlHandler->myListOfHypothesesSets.end();
++it )
{
QStringList GetAvailableHypotheses( const bool isAlgo,
const int theDim,
const bool isAux,
- const bool isNeedGeometry,
+ const bool hasGeometry,
const bool isSubMesh)
{
QStringList aHypList;
// Init list of available hypotheses, if needed
InitAvailableHypotheses();
- bool checkGeometry = ( !isNeedGeometry && isAlgo );
+ bool checkGeometry = ( isAlgo );
const char* context = isSubMesh ? "LOCAL" : "GLOBAL";
// fill list of hypotheses/algorithms
THypothesisDataMap& pMap = isAlgo ? myAlgorithmsMap : myHypothesesMap;
THypothesisDataMap::ConstIterator anIter;
- for ( anIter = pMap.begin(); anIter != pMap.end(); anIter++ ) {
+ for ( anIter = pMap.begin(); anIter != pMap.end(); anIter++ )
+ {
HypothesisData* aData = anIter.value();
- if(!aData || aData->Label.isEmpty()) continue;
- if (( theDim < 0 || aData->Dim.contains( theDim )) &&
- ( isAlgo || aData->IsAuxOrNeedHyp == isAux ) &&
- ( aData->Context == "ANY" || aData->Context == context ))
+ if (( aData && !aData->Label.isEmpty() ) &&
+ ( theDim < 0 || aData->Dim.contains( theDim )) &&
+ ( isAlgo || aData->IsAuxOrNeedHyp == isAux ) &&
+ ( aData->Context == "ANY" || aData->Context == context ) &&
+ ( !checkGeometry || (!aData->IsNeedGeometry ||
+ ( aData->IsNeedGeometry > 0 ) == hasGeometry)))
{
- if (checkGeometry) {
- if (aData->IsNeedGeometry == isNeedGeometry)
- aHypList.append(anIter.key());
- }
- else {
- aHypList.append(anIter.key());
- }
+ aHypList.append(anIter.key());
}
}
return aHypList;
}
- QStringList GetHypothesesSets(int maxDim, const QString& MeshType)
+ QStringList GetHypothesesSets(int maxDim)
{
QStringList aSetNameList;
InitAvailableHypotheses();
QList<HypothesesSet*>::iterator hypoSet;
for ( hypoSet = myListOfHypothesesSets.begin();
- hypoSet != myListOfHypothesesSets.end();
- ++hypoSet ) {
+ hypoSet != myListOfHypothesesSets.end();
+ ++hypoSet ) {
HypothesesSet* aSet = *hypoSet;
- bool isAvailable = false;
- if ( !MeshType.isEmpty() )
- {
- if ( aSet->maxDim() != maxDim)
- continue;
- aSet->init( true );
- while ( aSet->next(), aSet->more() )
- {
- if ( HypothesisData* hypData = SMESH::GetHypothesisData( aSet->current() ) )
- {
- QStringList::const_iterator inElemType = hypData->OutputTypes.begin();
- for ( ; inElemType != hypData->OutputTypes.end(); inElemType++ )
- {
- if ( *inElemType == MeshType ){
- isAvailable = true;
- break;
- }
- }
- }
- if ( isAvailable ) break;
- }
- }
- else if ( aSet && ( aSet->count( true ) || aSet->count( false )) &&
- aSet->maxDim() <= maxDim)
+ if ( aSet && 0 <= aSet->maxDim() && aSet->maxDim() <= maxDim )
{
- isAvailable = true;
+ aSetNameList.append( mangledHypoSetName( aSet ));
}
- if ( isAvailable ) aSetNameList.append( mangledHypoSetName( aSet ));
}
aSetNameList.removeDuplicates();
aSetNameList.sort();
QStringList reversedNames;
for ( int i = 0; i < aSetNameList.count(); ++i )
reversedNames.prepend( aSetNameList[i] );
-
+
return reversedNames;
}
{
QString name = demangledHypoSetName( theSetName );
QList<HypothesesSet*>::iterator hypoSet;
- for ( hypoSet = myListOfHypothesesSets.begin();
+ for ( hypoSet = myListOfHypothesesSets.begin();
hypoSet != myListOfHypothesesSets.end();
++hypoSet ) {
HypothesesSet* aSet = *hypoSet;
return aHypData;
}
+ //================================================================================
+ /*!
+ * \brief Return the HypothesisData holding a name of a group of hypotheses
+ * a given hypothesis belongs to
+ */
+ //================================================================================
+
+ HypothesisData* GetGroupTitle( const HypothesisData* hyp, const bool isAlgo )
+ {
+ static std::vector< std::vector< HypothesisData > > theGroups;
+ if ( theGroups.empty() )
+ {
+ theGroups.resize(14); // 14: isAlgo * 10 + dim
+
+ QString dummyS("GROUP");
+ QList<int> dummyIL; dummyIL << 1;
+ QStringList dummySL;
+ HypothesisData group( dummyS,dummyS,dummyS,dummyS,dummyS,dummyS,dummyS,-1,-1,
+ dummyIL, 0, dummySL,dummySL,dummySL,dummySL,0,0 );
+ // no group
+ int key = 0;
+ theGroups[ key ].push_back( group );
+
+ // 1D algo
+ key = 11;
+ // 0: Basic
+ group.Label = "GROUP:" + QObject::tr( "SMESH_1D_ALGO_GROUP_BASIC" );
+ theGroups[ key ].push_back( group );
+ // 1: Advanced
+ group.Label = "GROUP:" + QObject::tr( "SMESH_1D_ALGO_GROUP_ADVANCED" );
+ theGroups[ key ].push_back( group );
+
+ // 1D hypotheses
+ key = 01;
+ // 0: Basic
+ group.Label = "GROUP:" + QObject::tr( "SMESH_1D_HYP_GROUP_BASIC" );
+ theGroups[ key ].push_back( group );
+ // 1: Progression
+ group.Label = "GROUP:" + QObject::tr( "SMESH_1D_HYP_GROUP_PROGRESSION" );
+ theGroups[ key ].push_back( group );
+ // 2: Advanced
+ group.Label = "GROUP:" + QObject::tr( "SMESH_1D_HYP_GROUP_ADVANCED" );
+ theGroups[ key ].push_back( group );
+
+ // 2D algo
+ key = 12;
+ // 0: Regular
+ group.Label = "GROUP:" + QObject::tr( "SMESH_2D_ALGO_GROUP_REGULAR" );
+ theGroups[ key ].push_back( group );
+ // 1: Free
+ group.Label = "GROUP:" + QObject::tr( "SMESH_2D_ALGO_GROUP_FREE" );
+ theGroups[ key ].push_back( group );
+ // 2: Advanced
+ group.Label = "GROUP:" + QObject::tr( "SMESH_2D_ALGO_GROUP_ADVANCED" );
+ theGroups[ key ].push_back( group );
+
+ // 3D algo
+ key = 13;
+ // 0: Regular
+ group.Label = "GROUP:" + QObject::tr( "SMESH_3D_ALGO_GROUP_REGULAR" );
+ theGroups[ key ].push_back( group );
+ // 1: Free
+ group.Label = "GROUP:" + QObject::tr( "SMESH_3D_ALGO_GROUP_FREE" );
+ theGroups[ key ].push_back( group );
+ // 2: Advanced
+ group.Label = "GROUP:" + QObject::tr( "SMESH_3D_ALGO_GROUP_ADVANCED" );
+ theGroups[ key ].push_back( group );
+ }
+
+ size_t key = 0, groupID = 0;
+ if ( hyp && !hyp->Dim.isEmpty() )
+ {
+ key = hyp->Dim[0] + isAlgo * 10;
+ groupID = hyp->GroupID;
+ }
+
+ if ( key < theGroups.size() && !theGroups[ key ].empty() )
+ {
+ std::vector< HypothesisData > & group = theGroups[ key ];
+ return & ( groupID < group.size() ? group[ groupID ] : group.back() );
+ }
+ return & theGroups[ 0 ][ 0 ];
+ }
+
bool IsAvailableHypothesis(const HypothesisData* algoData,
const QString& hypType,
bool& isAuxiliary)
return false;
if ( algoData->BasicHypos.contains( hypType ))
return true;
- if ( algoData->OptionalHypos.contains( hypType)) {
+ if ( algoData->OptionalHypos.contains( hypType )) {
isAuxiliary = true;
return true;
}
// 2. Get names of plugin libraries
HypothesisData* aHypData = GetHypothesisData(aHypType);
- if (!aHypData)
+ if (!aHypData)
return aCreator;
QString aClientLibName = aHypData->ClientLibName;
try {
// load plugin library
if(MYDEBUG) MESSAGE("Loading client meshers plugin library ...");
- LibHandle libHandle = LoadLib( aClientLibName.toLatin1().data() );
+#ifdef WIN32
+#ifdef UNICODE
+ LPTSTR path = new TCHAR[aClientLibName.length() + 1];
+ path[aClientLibName.toWCharArray(path)] = '\0';
+#else
+ QByteArray baPath = aClientLibName.toUtf8();
+ const char* path = baPath.data();
+#endif
+#else
+ QByteArray baPath = aClientLibName.toUtf8();
+ char* path = baPath.data();
+#endif
+ LibHandle libHandle = LoadLib( path );
+#if defined(WIN32) && defined(UNICODE)
+ delete path;
+#endif
if (!libHandle) {
- // report any error, if occured
+ // report any error, if occurred
{
#ifdef WIN32
const char* anError = "Can't load client meshers plugin library";
#else
- const char* anError = dlerror();
+ const char* anError = dlerror();
#endif
INFOS(anError); // always display this kind of error !
}
//rnv : This dynamic property of the QObject stores the name of the plugin.
// It is used to obtain plugin root dir environment variable
- // in the SMESHGUI_HypothesisDlg class. Plugin root dir environment
+ // in the SMESHGUI_HypothesisDlg class. Plugin root dir environment
// variable is used to display documentation.
- aCreator->setProperty(PLUGIN_NAME,aHypData->PluginName);
+ aCreator->setProperty(SMESH::Plugin_Name(),aHypData->PluginName);
}
}
}
SMESH::SMESH_Hypothesis_ptr CreateHypothesis(const QString& aHypType,
const QString& aHypName,
- const bool isAlgo)
+ const bool /*isAlgo*/)
{
- if(MYDEBUG) MESSAGE("Create " << aHypType.toLatin1().data() <<
+ if(MYDEBUG) MESSAGE("Create " << aHypType.toLatin1().data() <<
" with name " << aHypName.toLatin1().data());
HypothesisData* aHypData = GetHypothesisData(aHypType);
QString aServLib = aHypData->ServerLibName;
try {
SMESH::SMESH_Hypothesis_var aHypothesis;
aHypothesis = SMESHGUI::GetSMESHGen()->CreateHypothesis(aHypType.toLatin1().data(),
- aServLib.toLatin1().data());
+ aServLib.toUtf8().data());
if (!aHypothesis->_is_nil()) {
_PTR(SObject) aHypSObject = SMESH::FindSObject(aHypothesis.in());
if (aHypSObject) {
return SMESH::SMESH_Hypothesis::_nil();
}
+ bool IsApplicable(const QString& aHypType,
+ GEOM::GEOM_Object_ptr theGeomObject,
+ const bool toCheckAll)
+ {
+ if ( getenv("NO_LIMIT_ALGO_BY_SHAPE")) // allow a workaround for a case if
+ return true; // IsApplicable() returns false due to a bug
+
+ HypothesisData* aHypData = GetHypothesisData(aHypType);
+ QString aServLib = aHypData->ServerLibName;
+ return SMESHGUI::GetSMESHGen()->IsApplicable( aHypType.toLatin1().data(),
+ aServLib.toUtf8().data(),
+ theGeomObject,
+ toCheckAll);
+ }
+
bool AddHypothesisOnMesh (SMESH::SMESH_Mesh_ptr aMesh, SMESH::SMESH_Hypothesis_ptr aHyp)
{
_PTR(SObject) SM = SMESH::FindSObject(aMesh);
GEOM::GEOM_Object_var aShapeObject = SMESH::GetShapeOnMeshOrSubMesh(SM);
try {
- res = aMesh->AddHypothesis(aShapeObject, aHyp);
- if (res < SMESH::HYP_UNKNOWN_FATAL) {
- _PTR(SObject) aSH = SMESH::FindSObject(aHyp);
- if (SM && aSH) {
- SMESH::ModifiedMesh(SM, false, aMesh->NbNodes()==0);
- }
- }
+ CORBA::String_var error;
+ res = aMesh->AddHypothesis(aShapeObject, aHyp, error.out());
if (res > SMESH::HYP_OK) {
wc.suspend();
- processHypothesisStatus(res, aHyp, true);
+ processHypothesisStatus(res, aHyp, true, error.in() );
wc.resume();
}
}
int res = SMESH::HYP_UNKNOWN_FATAL;
SUIT_OverrideCursor wc;
- if (!aSubMesh->_is_nil() && ! aHyp->_is_nil()) {
+ if ( !aSubMesh->_is_nil() && !aHyp->_is_nil() ) {
try {
SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
_PTR(SObject) SsubM = SMESH::FindSObject(aSubMesh);
GEOM::GEOM_Object_var aShapeObject = SMESH::GetShapeOnMeshOrSubMesh(SsubM);
- if (!aMesh->_is_nil() && SsubM && !aShapeObject->_is_nil()) {
- res = aMesh->AddHypothesis(aShapeObject, aHyp);
- if (res < SMESH::HYP_UNKNOWN_FATAL) {
- _PTR(SObject) meshSO = SMESH::FindSObject(aMesh);
- if (meshSO)
- SMESH::ModifiedMesh(meshSO, false, aMesh->NbNodes()==0);
- }
+ if (!aMesh->_is_nil() && SsubM && !aShapeObject->_is_nil())
+ {
+ CORBA::String_var error;
+ res = aMesh->AddHypothesis( aShapeObject, aHyp, error.out() );
if (res > SMESH::HYP_OK) {
wc.suspend();
- processHypothesisStatus(res, aHyp, true);
+ processHypothesisStatus( res, aHyp, true, error.in() );
wc.resume();
}
}
SUIT_OverrideCursor wc;
try {
- _PTR(Study) aStudy = GetActiveStudyDocument();
+ _PTR(Study) aStudy = getStudy();
_PTR(SObject) aHypObj = aStudy->FindObjectID( IObject->getEntry() );
if( aHypObj )
+ {
+ _PTR(SObject) MorSM = SMESH::GetMeshOrSubmesh( aHypObj );
+ _PTR(SObject) aRealHypo;
+ if( aHypObj->ReferencedObject( aRealHypo ) )
{
- _PTR(SObject) MorSM = SMESH::GetMeshOrSubmesh( aHypObj );
- _PTR(SObject) aRealHypo;
- if( aHypObj->ReferencedObject( aRealHypo ) )
- {
- SMESH_Hypothesis_var hypo = SMESH_Hypothesis::_narrow( SObjectToObject( aRealHypo ) );
- RemoveHypothesisOrAlgorithmOnMesh( MorSM, hypo );
- }
- else
- {
- SMESH_Hypothesis_var hypo = SMESH_Hypothesis::_narrow( SObjectToObject( aHypObj ) );
- SObjectList meshList = GetMeshesUsingAlgoOrHypothesis( hypo );
- for( int i = 0; i < meshList.size(); i++ )
- RemoveHypothesisOrAlgorithmOnMesh( meshList[ i ], hypo );
- }
+ SMESH_Hypothesis_var hypo = SMESH_Hypothesis::_narrow( SObjectToObject( aRealHypo ) );
+ RemoveHypothesisOrAlgorithmOnMesh( MorSM, hypo );
}
+ else
+ {
+ SMESH_Hypothesis_var hypo = SMESH_Hypothesis::_narrow( SObjectToObject( aHypObj ) );
+ SObjectList meshList = GetMeshesUsingAlgoOrHypothesis( hypo );
+ for( size_t i = 0; i < meshList.size(); i++ )
+ RemoveHypothesisOrAlgorithmOnMesh( meshList[ i ], hypo );
+ }
+ }
}
catch(const SALOME::SALOME_Exception& S_ex)
- {
- wc.suspend();
- SalomeApp_Tools::QtCatchCorbaException(S_ex);
- res = SMESH::HYP_UNKNOWN_FATAL;
- }
+ {
+ wc.suspend();
+ SalomeApp_Tools::QtCatchCorbaException(S_ex);
+ res = SMESH::HYP_UNKNOWN_FATAL;
+ }
return res < SMESH::HYP_UNKNOWN_FATAL;
}
if (!aSubMesh->_is_nil())
aMesh = aSubMesh->GetFather();
- if (!aMesh->_is_nil()) {
+ if (!aMesh->_is_nil()) {
if (aMesh->HasShapeToMesh() && !aShapeObject->_is_nil()) {
res = aMesh->RemoveHypothesis(aShapeObject, anHyp);
- if (res < SMESH::HYP_UNKNOWN_FATAL) {
- _PTR(SObject) meshSO = SMESH::FindSObject(aMesh);
- if (meshSO)
- SMESH::ModifiedMesh(meshSO, false, aMesh->NbNodes()==0);
- }
-
}
else if(!aMesh->HasShapeToMesh()){
res = aMesh->RemoveHypothesis(aShapeObject, anHyp);
- if (res < SMESH::HYP_UNKNOWN_FATAL) {
- _PTR(SObject) meshSO = SMESH::FindSObject(aMesh);
- if (meshSO)
- SMESH::ModifiedMesh(meshSO, false, aMesh->NbNodes()==0);
- }
}
if (res > SMESH::HYP_OK) {
wc.suspend();
processHypothesisStatus(res, anHyp, false);
wc.resume();
}
+ if ( _PTR(SObject) meshSO = SMESH::FindSObject(aMesh) )
+ {
+ if ( SMESH_Actor* actor = SMESH::FindActorByEntry( meshSO->GetID().c_str() ))
+ if( actor->GetVisibility() )
+ actor->Update();
+ }
}
} catch(const SALOME::SALOME_Exception& S_ex) {
wc.suspend();
if (!AlgoOrHyp->_is_nil()) {
_PTR(SObject) SO_Hypothesis = SMESH::FindSObject(AlgoOrHyp);
if (SO_Hypothesis) {
- SObjectList listSO =
- SMESHGUI::activeStudy()->studyDS()->FindDependances(SO_Hypothesis);
+ SObjectList listSO = SMESH::getStudy()->FindDependances(SO_Hypothesis);
if(MYDEBUG) MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): dependency number ="<<listSO.size());
for (unsigned int i = 0; i < listSO.size(); i++) {
QString GetMessageOnAlgoStateErrors(const algo_error_array& errors)
{
QString resMsg; // PAL14861 = QObject::tr("SMESH_WRN_MISSING_PARAMETERS") + ":\n";
- for ( int i = 0; i < errors.length(); ++i ) {
+ for ( size_t i = 0; i < errors.length(); ++i ) {
const SMESH::AlgoStateError & error = errors[ i ];
const bool hasAlgo = ( strlen( error.algoName ) != 0 );
QString msg;
if ( !hasAlgo )
msg = QObject::tr( "STATE_ALGO_MISSING" );
- else
+ else
switch( error.state ) {
CASE2MESSAGE( HYP_MISSING );
CASE2MESSAGE( HYP_NOTCONFORM );