X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_Hypotheses.cxx;h=ac8e4194ddd343c2179658da97b2d0c0bd4d0c4a;hp=c3bb0138206f7f504bcc35588289cc814a922bc7;hb=251f8c052dd12dd29922210dc901b295fe999a0e;hpb=e4737e85f0da6d3f90fd08f6be1c2825195fe16f diff --git a/src/SMESHGUI/SMESHGUI_Hypotheses.cxx b/src/SMESHGUI/SMESHGUI_Hypotheses.cxx index c3bb01382..ac8e4194d 100644 --- a/src/SMESHGUI/SMESHGUI_Hypotheses.cxx +++ b/src/SMESHGUI/SMESHGUI_Hypotheses.cxx @@ -1,490 +1,833 @@ -// Copyright (C) 2003 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. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org - -#include -#include +// 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 +// +// 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, 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 +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// +// File : SMESHGUI_Hypotheses.cxx +// Author : Julia DOROVSKIKH, Open CASCADE S.A.S. +// SMESH includes #include "SMESHGUI_Hypotheses.h" + +#include "SMESHGUI.h" +#include "SMESHGUI_HypothesesUtils.h" #include "SMESHGUI_Utils.h" +#include "SMESHGUI_SpinBox.h" -#ifdef _DEBUG_ -static int MYDEBUG = 0; -#else -static int MYDEBUG = 0; -#endif +// SALOME KERNEL includes +#include +#include -namespace SMESH{ - - using namespace std; +// SALOME GUI includes +#include +#include +#include +#include +#include - typedef map THypothesisDataMap; - THypothesisDataMap myHypothesesMap; - THypothesisDataMap myAlgorithmsMap; +// Qt includes +#include +#include +#include +#include +#include - typedef map THypCreatorMap; - THypCreatorMap myHypCreatorMap; +#define SPACING 6 +#define MARGIN 11 - void InitAvailableHypotheses() - { - QAD_WaitCursor wc; - if (myHypothesesMap.empty() && myAlgorithmsMap.empty()) { - // Resource manager - QAD_ResourceMgr* resMgr = QAD_Desktop::createResourceManager(); - if (!resMgr) return; - - // Find name of a resource XML file ("SMESH_Meshers.xml"); - QString HypsXml; - char* cenv = getenv("SMESH_MeshersList"); - if (cenv) - HypsXml.sprintf("%s", cenv); - - QStringList HypsXmlList = QStringList::split( ":", HypsXml, false ); - if (HypsXmlList.count() == 0) - { - QAD_MessageBox::error1(QAD_Application::getDesktop(), - tr("SMESH_WRN_WARNING"), - tr("MESHERS_FILE_NO_VARIABLE"), - tr("SMESH_BUT_OK")); - return; - } - - // loop on files in HypsXml - QString aNoAccessFiles; - for ( int i = 0; i < HypsXmlList.count(); i++ ) { - QString HypsXml = HypsXmlList[ i ]; - - // Find full path to the resource XML file - QString xmlFile = HypsXml + ".xml"; - xmlFile = QAD_Tools::addSlash(resMgr->findFile(xmlFile, HypsXml)) + xmlFile; - - QFile file (QAD_Tools::unix2win(xmlFile)); - if (file.exists() && file.open(IO_ReadOnly)) { - file.close(); - - SMESHGUI_XmlHandler* myXmlHandler = new SMESHGUI_XmlHandler(); - ASSERT(myXmlHandler); - - QXmlInputSource source (file); - QXmlSimpleReader reader; - reader.setContentHandler(myXmlHandler); - reader.setErrorHandler(myXmlHandler); - bool ok = reader.parse(source); - file.close(); - if (ok) { - addMap( myXmlHandler->myHypothesesMap, myHypothesesMap ); - addMap( myXmlHandler->myAlgorithmsMap, myAlgorithmsMap ); - } - else { - QAD_MessageBox::error1(myDesktop, - tr("INF_PARSE_ERROR"), - tr(myXmlHandler->errorProtocol()), - tr("SMESH_BUT_OK")); - } - } - else { - if (aNoAccessFiles.isEmpty()) - aNoAccessFiles = xmlFile; - else - aNoAccessFiles += ", " + xmlFile; - } - } // end loop - - - if (!aNoAccessFiles.isEmpty()) { - QString aMess = tr("MESHERS_FILE_CANT_OPEN") + " " + aNoAccessFiles + "\n"; - aMess += tr("MESHERS_FILE_CHECK_VARIABLE"); - wc.stop(); - QAD_MessageBox::warn1(QAD_Application::getDesktop(), - tr("SMESH_WRN_WARNING"), - aMess, - tr("SMESH_BUT_OK")); - wc.start(); - } +SMESHGUI_GenericHypothesisCreator::SMESHGUI_GenericHypothesisCreator( const QString& theHypType ) + : myToDeleteInitParamsHypo( false ), + myHypType( theHypType ), + myIsCreate( false ), + myDlg( 0 ) +{ +} + +SMESHGUI_GenericHypothesisCreator::~SMESHGUI_GenericHypothesisCreator() +{ + if ( myToDeleteInitParamsHypo && !myInitParamsHypo->_is_nil() ) + myInitParamsHypo->UnRegister(); +} + +void SMESHGUI_GenericHypothesisCreator::setInitParamsHypothesis(SMESH::SMESH_Hypothesis_ptr hyp) +{ + if ( !CORBA::is_nil( hyp ) ) { + if ( myToDeleteInitParamsHypo && !myInitParamsHypo->_is_nil() ) + myInitParamsHypo->UnRegister(); + CORBA::String_var hypName = hyp->GetName(); + if ( hypType() == hypName.in() ) + { + myInitParamsHypo = SMESH::SMESH_Hypothesis::_duplicate( hyp ); + myToDeleteInitParamsHypo = !SMESH::FindSObject( myInitParamsHypo ); } } +} + +void SMESHGUI_GenericHypothesisCreator::create( SMESH::SMESH_Hypothesis_ptr initParamsHyp, + const QString& theHypName, + QWidget* parent, QObject* obj, const QString& slot ) +{ + MESSAGE( "Creation of hypothesis with initial params" ); + setInitParamsHypothesis( initParamsHyp ); + create( false, theHypName, parent, obj, slot ); +} +void SMESHGUI_GenericHypothesisCreator::create( bool isAlgo, + const QString& theHypName, + QWidget* theParent, QObject* obj, const QString& slot ) +{ + MESSAGE( "Creation of hypothesis" ); - GetAvailableHypotheses (const bool isAlgo) - { - QStringList aHypList; - - // Init list of available hypotheses, if needed - InitAvailableHypotheses(); - - // fill list of hypotheses/algorithms - THypothesisDataMap::iterator anIter; - if (isAlgo) { - anIter = myAlgorithmsMap.begin(); - for (; anIter != myAlgorithmsMap.end(); anIter++) { - aHypList.append(((*anIter).first).c_str()); - } - } - else { - anIter = myHypothesesMap.begin(); - for (; anIter != myHypothesesMap.end(); anIter++) { - aHypList.append(((*anIter).first).c_str()); - } - } - - return aHypList; + myIsCreate = true; + + // Create hypothesis/algorithm + if (isAlgo) { + SMESH::SMESH_Hypothesis_var anAlgo = + SMESH::CreateHypothesis( hypType(), theHypName, isAlgo ); + anAlgo.out(); // avoid unused variable warning + } + else { + SMESH::SMESH_Hypothesis_var aHypothesis = + SMESH::CreateHypothesis( hypType(), theHypName, false ); + editHypothesis( aHypothesis.in(), theHypName, theParent, obj, slot ); } - +} + +void SMESHGUI_GenericHypothesisCreator::edit( SMESH::SMESH_Hypothesis_ptr theHypothesis, + const QString& theHypName, + QWidget* theParent, QObject* obj, const QString& slot ) +{ + if( CORBA::is_nil( theHypothesis ) ) + return; + + myIsCreate = false; - HypothesisData* GetHypothesisData (const char* aHypType) + editHypothesis( theHypothesis, theHypName, theParent, obj, slot ); +} + +void SMESHGUI_GenericHypothesisCreator::editHypothesis( SMESH::SMESH_Hypothesis_ptr h, + const QString& theHypName, + QWidget* theParent, + QObject* obj, const QString& slot ) +{ + myHypName = theHypName; + myHypo = SMESH::SMESH_Hypothesis::_duplicate( h ); + myHypo->Register(); + + SMESHGUI_HypothesisDlg* Dlg = new SMESHGUI_HypothesisDlg( this, theParent ); + connect( Dlg, SIGNAL( finished( int ) ), this, SLOT( onDialogFinished( int ) ) ); + connect( this, SIGNAL( finished( int ) ), obj, slot.toLatin1().constData() ); + connect( SMESHGUI::GetSMESHGUI(), SIGNAL( SignalCloseAllDialogs() ), Dlg, SLOT( reject() )); + + myDlg = Dlg; + QFrame* fr = buildFrame(); + if( fr ) { - HypothesisData* aHypData = 0; + Dlg->setCustomFrame( fr ); + Dlg->setWindowTitle( caption() ); + Dlg->setObjectName( theHypName ); + Dlg->setHIcon( icon() ); + Dlg->setType( type() ); + retrieveParams(); + Dlg->show(); + Dlg->resize( Dlg->minimumSizeHint() ); + } + else { + emit finished( QDialog::Accepted ); + delete myDlg; + } +} + +QFrame* SMESHGUI_GenericHypothesisCreator::buildStdFrame() +{ + if( CORBA::is_nil( hypothesis() ) ) + return 0; + + ListOfStdParams params; + if( !stdParams( params ) || params.isEmpty() ) + return 0; + + QFrame* fr = new QFrame( 0 ); + QVBoxLayout* lay = new QVBoxLayout( fr ); + lay->setMargin( 5 ); + lay->setSpacing( 0 ); + + QGroupBox* GroupC1 = new QGroupBox( tr( "SMESH_ARGUMENTS" ), fr ); + lay->addWidget( GroupC1 ); - // Init list of available hypotheses, if needed - InitAvailableHypotheses(); + QGridLayout* GroupC1Layout = new QGridLayout( GroupC1 ); + GroupC1Layout->setSpacing( SPACING ); + GroupC1Layout->setMargin( MARGIN ); - if (myHypothesesMap.find(aHypType) == myHypothesesMap.end()) { - if (myAlgorithmsMap.find(aHypType) != myAlgorithmsMap.end()) { - aHypData = myAlgorithmsMap[aHypType]; + ListOfStdParams::const_iterator anIt = params.begin(), aLast = params.end(); + for( int i=0; anIt!=aLast; anIt++, i++ ) + { + QLabel* lab = new QLabel( (*anIt).myName, GroupC1 ); + GroupC1Layout->addWidget( lab, i, 0 ); + myParamLabels << lab; + + QWidget* w = getCustomWidget( *anIt, GroupC1, i ); + if ( !w ) + switch( (*anIt).myValue.type() ) + { + case QVariant::Int: + { + SalomeApp_IntSpinBox* sb = new SalomeApp_IntSpinBox( GroupC1 ); + sb->setObjectName( (*anIt).myName ); + attuneStdWidget( sb, i ); + sb->setValue( (*anIt).myValue.toInt() ); + connect( sb, SIGNAL( valueChanged( int ) ), this, SLOT( onValueChanged() ) ); + w = sb; + } + break; + case QVariant::Double: + { + SalomeApp_DoubleSpinBox* sb = new SMESHGUI_SpinBox( GroupC1 ); + sb->setObjectName( (*anIt).myName ); + attuneStdWidget( sb, i ); + sb->setValue( (*anIt).myValue.toDouble() ); + connect( sb, SIGNAL( valueChanged( double ) ), this, SLOT( onValueChanged() ) ); + w = sb; + } + break; + case QVariant::String: + { + if((*anIt).isVariable) { + _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); + QString aVar = (*anIt).myValue.toString(); + if(aStudy->IsInteger(aVar.toLatin1().constData())){ + SalomeApp_IntSpinBox* sb = new SalomeApp_IntSpinBox( GroupC1 ); + sb->setObjectName( (*anIt).myName ); + attuneStdWidget( sb, i ); + sb->setText( aVar ); + connect( sb, SIGNAL( valueChanged( int ) ), this, SLOT( onValueChanged() ) ); + w = sb; + } + else if(aStudy->IsReal(aVar.toLatin1().constData())){ + SalomeApp_DoubleSpinBox* sb = new SMESHGUI_SpinBox( GroupC1 ); + sb->setObjectName( (*anIt).myName ); + attuneStdWidget( sb, i ); + sb->setText( aVar ); + connect( sb, SIGNAL( valueChanged( double ) ), this, SLOT( onValueChanged() ) ); + w = sb; + } + } + else { + QLineEdit* le = new QLineEdit( GroupC1 ); + le->setObjectName( (*anIt).myName ); + attuneStdWidget( le, i ); + le->setText( (*anIt).myValue.toString() ); + connect( le, SIGNAL( textChanged( const QString& ) ), this, SLOT( onValueChanged() ) ); + w = le; + } + } + break; } + + if( w ) + { + GroupC1Layout->addWidget( w, i, 1 ); + changeWidgets().append( w ); } - else { - aHypData = myHypothesesMap[aHypType]; - } - return aHypData; } + return fr; +} + +void SMESHGUI_GenericHypothesisCreator::onValueChanged() +{ + valueChanged( (QWidget*) sender() ); +} + +void SMESHGUI_GenericHypothesisCreator::valueChanged( QWidget* ) +{ +} + +void SMESHGUI_GenericHypothesisCreator::onDialogFinished( int result ) +{ + bool res = result==QDialog::Accepted; + if( res ) + { + /*QString paramValues = */storeParams(); + // No longer needed since NoteBook appears and "Value" OB field shows names of variable +// if ( !paramValues.isEmpty() ) { +// if ( _PTR(SObject) SHyp = SMESH::FindSObject( myHypo )) +// SMESH::SetValue( SHyp, paramValues ); +// } + } + + changeWidgets().clear(); - SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator (const QString& aHypType) + if( myIsCreate && !res ) { - const char* sHypType = aHypType.latin1(); - if(MYDEBUG) MESSAGE("Get HypothesisCreator for " << sHypType); - - SMESHGUI_GenericHypothesisCreator* aCreator = 0; - - // check, if creator for this hypothesis type already exists - if (myHypCreatorMap.find(sHypType) != myHypCreatorMap.end()) { - aCreator = myHypCreatorMap[sHypType]; + //remove just created hypothesis + _PTR(SObject) aHypSObject = SMESH::FindSObject( myHypo ); + _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); + if( aStudy && !aStudy->GetProperties()->IsLocked() ) + { + _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder(); + aBuilder->RemoveObjectWithChildren( aHypSObject ); } - else { - // 1. Init list of available hypotheses, if needed - InitAvailableHypotheses(); - - // 2. Get names of plugin libraries - HypothesisData* aHypData = GetHypothesisData(sHypType); - if (!aHypData) { - return aCreator; - } - QString aClientLibName = aHypData->ClientLibName; - QString aServerLibName = aHypData->ServerLibName; - - // 3. Load Client Plugin Library - try { - // load plugin library - if(MYDEBUG) MESSAGE("Loading client meshers plugin library ..."); - void* libHandle = dlopen (aClientLibName, RTLD_LAZY); - if (!libHandle) { - // report any error, if occured - const char* anError = dlerror(); - if(MYDEBUG) MESSAGE(anError); - } - else { - // get method, returning hypothesis creator - if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ..."); - typedef SMESHGUI_GenericHypothesisCreator* (*GetHypothesisCreator) \ - (QString aHypType, QString aServerLibName, SMESHGUI* aSMESHGUI); - GetHypothesisCreator procHandle = - (GetHypothesisCreator)dlsym( libHandle, "GetHypothesisCreator" ); - if (!procHandle) { - if(MYDEBUG) MESSAGE("bad hypothesis client plugin library"); - dlclose(libHandle); - } - else { - // get hypothesis creator - if(MYDEBUG) MESSAGE("Get Hypothesis Creator for " << aHypType); - aCreator = procHandle(aHypType, aServerLibName, smeshGUI); - if (!aCreator) { - if(MYDEBUG) MESSAGE("no such a hypothesis in this plugin"); - } - else { - // map hypothesis creator to a hypothesis name - myHypCreatorMap[sHypType] = aCreator; - } - } - } - } - catch (const SALOME::SALOME_Exception& S_ex) { - QtCatchCorbaException(S_ex); + } + else if( !myIsCreate && res ) + { + SMESH::SObjectList listSOmesh = SMESH::GetMeshesUsingAlgoOrHypothesis( myHypo ); + if( listSOmesh.size() > 0 ) + for( int i = 0; i < listSOmesh.size(); i++ ) + { + _PTR(SObject) submSO = listSOmesh[i]; + SMESH::SMESH_Mesh_var aMesh = SMESH::SObjectToInterface( submSO ); + SMESH::SMESH_subMesh_var aSubMesh = SMESH::SObjectToInterface( submSO ); + if( !aSubMesh->_is_nil() ) + aMesh = aSubMesh->GetFather(); + _PTR(SObject) meshSO = SMESH::FindSObject( aMesh ); + SMESH::ModifiedMesh( meshSO, false, aMesh->NbNodes()==0); } - } - - return aCreator; } + SMESHGUI::GetSMESHGUI()->updateObjBrowser( true, 0 ); + myHypo->UnRegister(); + myHypo = SMESH::SMESH_Hypothesis::_nil(); + myInitParamsHypo = SMESH::SMESH_Hypothesis::_nil(); + + disconnect( myDlg, SIGNAL( finished( int ) ), this, SLOT( onDialogFinished( int ) ) ); + myDlg->close(); + //delete myDlg; since WA_DeleteOnClose==true + myDlg = 0; + emit finished( result ); +} +bool SMESHGUI_GenericHypothesisCreator::stdParams( ListOfStdParams& ) const +{ + return false; +} - SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const QString& aHypType, - const QString& aHypName, - const bool isAlgo = false) +bool SMESHGUI_GenericHypothesisCreator::getStdParamFromDlg( ListOfStdParams& params ) const +{ + bool res = true; + StdParam item; + ListOfWidgets::const_iterator anIt = widgets().begin(), aLast = widgets().end(); + for( ; anIt!=aLast; anIt++ ) { - if(MYDEBUG) MESSAGE("Create " << aHypType << " with name " << aHypName); - - SMESH::SMESH_Hypothesis_var Hyp; - - HypothesisData* aHypData = GetHypothesisData((char*)aHypType.latin1()); - QString aServLib = aHypData->ServerLibName; - - try { - Hyp = SMESH::GetSMESHGen()->CreateHypothesis(aHypType, aServLib); - if (!Hyp->_is_nil()) { - SALOMEDS::SObject_var SHyp = SMESH::FindSObject(Hyp.in()); - if (!SHyp->_is_nil()) { - if ( !aHypName.isEmpty() ) - SMESH::SetName( SHyp, aHypName ); - myActiveStudy->updateObjBrowser(true); - return Hyp._retn(); - } - } + item.myName = (*anIt)->objectName(); + if( (*anIt)->inherits( "SalomeApp_IntSpinBox" ) ) + { + SalomeApp_IntSpinBox* sb = ( SalomeApp_IntSpinBox* )( *anIt ); + item.myValue = sb->value(); + item.myText = sb->text(); + params.append( item ); + } + else if( (*anIt)->inherits( "SalomeApp_DoubleSpinBox" ) ) + { + SalomeApp_DoubleSpinBox* sb = ( SalomeApp_DoubleSpinBox* )( *anIt ); + item.myValue = sb->value(); + item.myText = sb->text(); + params.append( item ); } - catch (const SALOME::SALOME_Exception & S_ex) { - QtCatchCorbaException(S_ex); + else if( (*anIt)->inherits( "QLineEdit" ) ) + { + QLineEdit* line = ( QLineEdit* )( *anIt ); + item.myValue = item.myText = line->text(); + params.append( item ); } + else if ( getParamFromCustomWidget( item, *anIt )) + { + params.append( item ); + } + else + res = false; + } + return res; +} - return SMESH::SMESH_Hypothesis::_nil(); +QString SMESHGUI_GenericHypothesisCreator::getVariableName(const char* methodName) const +{ + SMESH::SMESH_Hypothesis_var h = hypothesis(); + if ( !h->_is_nil() ) + { + CORBA::String_var aVaribaleName = h->GetVarParameter( methodName ); + return QString( aVaribaleName.in() ); } + return QString(); +} +QStringList SMESHGUI_GenericHypothesisCreator::getVariablesFromDlg() const +{ + QStringList aResult; + ListOfWidgets::const_iterator anIt = widgets().begin(), aLast = widgets().end(); + for( ; anIt!=aLast; anIt++ ) { + if( (*anIt)->inherits( "QAbstractSpinBox" ) ) { + QAbstractSpinBox* sb = ( QAbstractSpinBox* )( *anIt ); + aResult.append(sb->text()); + } + } + return aResult; +} - bool AddHypothesisOnMesh (SMESH::SMESH_Mesh_ptr aMesh, SMESH::SMESH_Hypothesis_ptr aHyp) +QString SMESHGUI_GenericHypothesisCreator::stdParamValues( const ListOfStdParams& params) +{ + QString valueStr = ""; + ListOfStdParams::const_iterator param = params.begin(), aLast = params.end(); + uint len0 = 0; + for( int i=0; param!=aLast; param++, i++ ) { - if(MYDEBUG) MESSAGE ("SMESHGUI::AddHypothesisOnMesh"); - int res = SMESH::HYP_UNKNOWN_FATAL; - QAD_WaitCursor wc; - - if ( !aMesh->_is_nil() ) { - SALOMEDS::SObject_var SM = SMESH::FindSObject( aMesh ); - GEOM::GEOM_Object_var aShapeObject = SMESH::GetShapeOnMeshOrSubMesh(SM); - try { - res = aMesh->AddHypothesis( aShapeObject, aHyp ); - if ( res < SMESH::HYP_UNKNOWN_FATAL ) { - SALOMEDS::SObject_var SH = SMESH::FindSObject(aHyp); - if ( !SM->_is_nil() && !SH->_is_nil() ) { - SMESH::ModifiedMesh(SM, false); - } - } - if ( res > SMESH::HYP_OK ) { - wc.stop(); - processHypothesisStatus( res, aHyp, this, true ); - wc.start(); - } - } - catch( const SALOME::SALOME_Exception& S_ex ) { - wc.stop(); - QtCatchCorbaException( S_ex ); - res = SMESH::HYP_UNKNOWN_FATAL; - } + if ( valueStr.length() > len0 ) { + valueStr += "; "; + len0 = valueStr.length(); + } + switch( (*param).myValue.type() ) + { + case QVariant::Int: + valueStr += valueStr.number( (*param).myValue.toInt() ); + break; + case QVariant::Double: + valueStr += valueStr.number( (*param).myValue.toDouble() ); + break; + case QVariant::String: + valueStr += (*param).myValue.toString(); + break; + default: + QVariant valCopy = (*param).myValue; + valueStr += valCopy.toString(); } - return res < SMESH::HYP_UNKNOWN_FATAL; } + return valueStr; +} + +SMESH::SMESH_Hypothesis_var SMESHGUI_GenericHypothesisCreator::hypothesis() const +{ + return myHypo; +} + +void SMESHGUI_GenericHypothesisCreator::setShapeEntry( const QString& theEntry ) +{ + myShapeEntry = theEntry; +} + +//================================================================================ +/*! + * \brief Return hypothesis containing initial parameters + * \param strictly - if true, always return myInitParamsHypo, + * else, return myInitParamsHypo only in creation mode and if it + * is non-nil + */ +//================================================================================ + +SMESH::SMESH_Hypothesis_var SMESHGUI_GenericHypothesisCreator::initParamsHypothesis(const bool strictly) const +{ + if ( strictly ) + return myInitParamsHypo; + if ( !isCreation() || CORBA::is_nil( myInitParamsHypo )) + return myHypo; + return myInitParamsHypo; +} + +bool SMESHGUI_GenericHypothesisCreator::hasInitParamsHypothesis() const +{ + return !CORBA::is_nil( myInitParamsHypo ); +} + +QString SMESHGUI_GenericHypothesisCreator::hypType() const +{ + return myHypType; +} + +QString SMESHGUI_GenericHypothesisCreator::hypName() const +{ + return myHypName; +} + +const SMESHGUI_GenericHypothesisCreator::ListOfWidgets& SMESHGUI_GenericHypothesisCreator::widgets() const +{ + return myParamWidgets; +} + +SMESHGUI_GenericHypothesisCreator::ListOfWidgets& SMESHGUI_GenericHypothesisCreator::changeWidgets() +{ + return myParamWidgets; +} +//================================================================================ +/*! + * \brief Returns a QLabel of a spesified parameter. + * If isCreation(), the 1st label (supposed to be "Name") is not countered. + */ +//================================================================================ - bool AddHypothesisOnSubMesh (SMESH::SMESH_subMesh_ptr aSubMesh, SMESH::SMESH_Hypothesis_ptr aHyp) +QLabel* SMESHGUI_GenericHypothesisCreator::getLabel(int i) const +{ + if ( isCreation() ) + i++; + if ( i < myParamLabels.size() ) + return (QLabel*) myParamLabels.at(i); + return NULL; +} + +QtxDialog* SMESHGUI_GenericHypothesisCreator:: dlg() const +{ + return myDlg; +} + +bool SMESHGUI_GenericHypothesisCreator::isCreation() const +{ + return myIsCreate; +} + +void SMESHGUI_GenericHypothesisCreator::attuneStdWidget( QWidget*, const int ) const +{ +} + +QString SMESHGUI_GenericHypothesisCreator::caption() const +{ + return QString(); +} + +QPixmap SMESHGUI_GenericHypothesisCreator::icon() const +{ + return QPixmap(); +} + +QString SMESHGUI_GenericHypothesisCreator::type() const +{ + return QString(); +} +QWidget* SMESHGUI_GenericHypothesisCreator::getCustomWidget( const StdParam & /*param*/, + QWidget* /*parent*/, + const int /*index*/) const +{ + return 0; +} +bool SMESHGUI_GenericHypothesisCreator::getParamFromCustomWidget( StdParam&, QWidget* ) const +{ + return false; +} + +bool SMESHGUI_GenericHypothesisCreator::checkParams( QString& msg ) const +{ + bool ok = true; + ListOfWidgets::const_iterator anIt = widgets().begin(), aLast = widgets().end(); + for( ; anIt!=aLast; anIt++ ) { - if(MYDEBUG) MESSAGE( "SMESHGUI::AddHypothesisOnSubMesh() "); - int res = SMESH::HYP_UNKNOWN_FATAL; - QAD_WaitCursor wc; - - if ( !aSubMesh->_is_nil() && ! aHyp->_is_nil() ) { - try { - SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather(); - SALOMEDS::SObject_var SsubM = SMESH::FindSObject( aSubMesh ); - GEOM::GEOM_Object_var aShapeObject = SMESH::GetShapeOnMeshOrSubMesh( SsubM ); - if ( !aMesh->_is_nil() && !SsubM->_is_nil() && !aShapeObject->_is_nil() ) { - res = aMesh->AddHypothesis( aShapeObject, aHyp ); - if ( res < SMESH::HYP_UNKNOWN_FATAL ) { - SMESH::ModifiedMesh( SsubM, false ); - } - if ( res > SMESH::HYP_OK ) { - wc.stop(); - processHypothesisStatus( res, aHyp, this, true ); - wc.start(); - } - } - else { - SCRUTE( aHyp->_is_nil() ); - SCRUTE( aMesh->_is_nil() ); - SCRUTE( SsubM->_is_nil() ); - SCRUTE( aShapeObject->_is_nil() ); - } - } - catch( const SALOME::SALOME_Exception& S_ex ) { - wc.stop(); - QtCatchCorbaException( S_ex ); - res = SMESH::HYP_UNKNOWN_FATAL; - } + if( (*anIt)->inherits( "SalomeApp_IntSpinBox" ) ) + { + SalomeApp_IntSpinBox* sb = ( SalomeApp_IntSpinBox* )( *anIt ); + ok = sb->isValid( msg, true ) && ok; } - else { - SCRUTE( aSubMesh->_is_nil() ); - SCRUTE( aHyp->_is_nil() ); + else if( (*anIt)->inherits( "SalomeApp_DoubleSpinBox" ) ) + { + SalomeApp_DoubleSpinBox* sb = ( SalomeApp_DoubleSpinBox* )( *anIt ); + ok = sb->isValid( msg, true ) && ok; } - return res < SMESH::HYP_UNKNOWN_FATAL; } - - bool RemoveHypothesisOrAlgorithmOnMesh (const Handle(SALOME_InteractiveObject)& IObject) + return ok; +} + +void SMESHGUI_GenericHypothesisCreator::onReject() +{ +} + +QString SMESHGUI_GenericHypothesisCreator::helpPage() const +{ + QString aHypType = hypType(); + QString aHelpFileName = ""; + if ( aHypType == "LocalLength" ) + aHelpFileName = "a1d_meshing_hypo_page.html#average_length_anchor"; + else if ( aHypType == "MaxLength" ) + aHelpFileName = "a1d_meshing_hypo_page.html#max_length_anchor"; + else if ( aHypType == "Arithmetic1D") + aHelpFileName = "a1d_meshing_hypo_page.html#arithmetic_1d_anchor"; + else if ( aHypType == "GeometricProgression") + aHelpFileName = "a1d_meshing_hypo_page.html#geometric_1d_anchor"; + else if ( aHypType == "FixedPoints1D") + aHelpFileName = "a1d_meshing_hypo_page.html#fixed_points_1d_anchor"; + else if ( aHypType == "MaxElementArea") + aHelpFileName = "a2d_meshing_hypo_page.html#max_element_area_anchor"; + else if ( aHypType == "MaxElementVolume") + aHelpFileName = "max_element_volume_hypo_page.html"; + else if ( aHypType == "StartEndLength") + aHelpFileName = "a1d_meshing_hypo_page.html#start_and_end_length_anchor"; + else if ( aHypType == "Deflection1D") + aHelpFileName = "a1d_meshing_hypo_page.html#deflection_1d_anchor"; + else if ( aHypType == "Adaptive1D") + aHelpFileName = "a1d_meshing_hypo_page.html#adaptive_1d_anchor"; + else if ( aHypType == "AutomaticLength") + aHelpFileName = "a1d_meshing_hypo_page.html#automatic_length_anchor"; + else if ( aHypType == "NumberOfSegments") + aHelpFileName = "a1d_meshing_hypo_page.html#number_of_segments_anchor"; + else if ( aHypType == "ProjectionSource1D") + aHelpFileName = "projection_algos_page.html"; + else if ( aHypType == "ProjectionSource2D") + aHelpFileName = "projection_algos_page.html"; + else if ( aHypType == "ProjectionSource3D") + aHelpFileName = "projection_algos_page.html"; + else if ( aHypType == "NumberOfLayers") + aHelpFileName = "radial_prism_algo_page.html"; + else if ( aHypType == "NumberOfLayers2D") + aHelpFileName = "radial_quadrangle_1D2D_algo_page.html"; + else if ( aHypType == "LayerDistribution") + aHelpFileName = "radial_prism_algo_page.html"; + else if ( aHypType == "LayerDistribution2D") + aHelpFileName = "radial_quadrangle_1D2D_algo_page.html"; + else if ( aHypType == "SegmentLengthAroundVertex") + aHelpFileName = "segments_around_vertex_algo_page.html"; + else if ( aHypType == "QuadrangleParams") + aHelpFileName = "a2d_meshing_hypo_page.html#hypo_quad_params_anchor"; + else if ( aHypType == "ViscousLayers") + aHelpFileName = "additional_hypo_page.html#viscous_layers_anchor"; + else if ( aHypType == "ViscousLayers2D") + aHelpFileName = "additional_hypo_page.html#viscous_layers_anchor"; + else if ( aHypType == "ImportSource1D" || aHypType == "ImportSource2D") + aHelpFileName = "import_algos_page.html"; + return aHelpFileName; +} + +SMESHGUI_HypothesisDlg::SMESHGUI_HypothesisDlg( SMESHGUI_GenericHypothesisCreator* creator, QWidget* parent ) +: QtxDialog( parent, false, true ), + myCreator( creator ) +{ + setAttribute(Qt::WA_DeleteOnClose, true); + // setMinimumSize( 300, height() ); +// setFixedSize( 300, height() ); + QVBoxLayout* topLayout = new QVBoxLayout( mainFrame() ); + topLayout->setMargin( 0 ); + topLayout->setSpacing( 0 ); + + QFrame* titFrame = new QFrame( mainFrame() ); + QHBoxLayout* titLay = new QHBoxLayout( titFrame ); + titLay->setMargin( 0 ); + titLay->setSpacing( SPACING ); + + myIconLabel = new QLabel( titFrame ); + myIconLabel->setScaledContents( false ); + myIconLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) ); + myTypeLabel = new QLabel( titFrame ); + if( creator ) + myTypeLabel->setText( creator->hypType() ); + + titLay->addWidget( myIconLabel, 0 ); + titLay->addWidget( myTypeLabel, 0 ); + titLay->addStretch( 1 ); + + topLayout->addWidget( titFrame, 0 ); + + myHelpFileName = creator->helpPage(); + + connect( this, SIGNAL( dlgHelp() ), this, SLOT( onHelp() ) ); +} + +SMESHGUI_HypothesisDlg::~SMESHGUI_HypothesisDlg() +{ + delete myCreator; +} + +void SMESHGUI_HypothesisDlg::setCustomFrame( QFrame* f ) +{ + if( f ) { - int res = SMESH::HYP_UNKNOWN_FATAL; - QAD_WaitCursor wc; - - if (IObject->hasReference()) { - try { - SMESH::SMESH_Hypothesis_var anHyp = - SMESH::IObjectToInterface(IObject); - SALOMEDS::SObject_var SO_Applied_Hypothesis = - smeshGUI->myStudy->FindObjectID(IObject->getReference()); - if (!SO_Applied_Hypothesis->_is_nil()) { - SALOMEDS::SObject_var MorSM = SMESH::GetMeshOrSubmesh(SO_Applied_Hypothesis); - if (!MorSM->_is_nil()) { - GEOM::GEOM_Object_var aShape = SMESH::GetShapeOnMeshOrSubMesh(MorSM); - if (!aShape->_is_nil()){ - SMESH::SMESH_Mesh_var aMesh = - SMESH::SObjectToInterface(MorSM); - SMESH::SMESH_subMesh_var aSubMesh = - SMESH::SObjectToInterface(MorSM); - - if (!aSubMesh->_is_nil()) - aMesh = aSubMesh->GetFather(); - - if (!aMesh->_is_nil()) { - res = aMesh->RemoveHypothesis(aShape, anHyp); - if ( res < SMESH::HYP_UNKNOWN_FATAL ) - SMESH::ModifiedMesh(MorSM, false); - if ( res > SMESH::HYP_OK ) { - wc.stop(); - processHypothesisStatus( res, anHyp, this, false ); - wc.start(); - } - } - } - } - - SALOMEDS::SObject_var SO_Applied_Hypothesis = - smeshGUI->myStudy->FindObjectID(IObject->getReference()); - if (!SO_Applied_Hypothesis->_is_nil()) { - SALOMEDS::SObject_var MorSM = SMESH::GetMeshOrSubmesh(SO_Applied_Hypothesis); - if (!MorSM->_is_nil()) { - GEOM::GEOM_Object_var aShapeObject =SMESH::GetShapeOnMeshOrSubMesh(MorSM); - if (!aShapeObject->_is_nil()){ - SMESH::SMESH_Mesh_var aMesh = SMESH::SObjectToInterface(MorSM); - SMESH::SMESH_subMesh_var aSubMesh = SMESH::SObjectToInterface(MorSM); - - if (!aSubMesh->_is_nil()) - aMesh = aSubMesh->GetFather(); - - if (!aMesh->_is_nil()) { - res = aMesh->RemoveHypothesis(aShapeObject, anHyp); - if ( res < SMESH::HYP_UNKNOWN_FATAL ) - SMESH::ModifiedMesh(MorSM, false); - if ( res > SMESH::HYP_OK ) { - wc.stop(); - processHypothesisStatus( res, anHyp, this, false ); - wc.start(); - } - } - } - } - } - } - } - catch( const SALOME::SALOME_Exception& S_ex ) { - wc.stop(); - QtCatchCorbaException( S_ex ); - res = SMESH::HYP_UNKNOWN_FATAL; - } - } - else if (IObject->hasEntry()) { - if(MYDEBUG) MESSAGE("IObject entry " << IObject->getEntry()); - } - return res < SMESH::HYP_UNKNOWN_FATAL; + f->setParent( mainFrame() ); + qobject_cast( mainFrame()->layout() )->insertWidget( 1, f, 1 ); } - - bool RemoveHypothesisOrAlgorithmOnMesh (SALOMEDS::SObject_ptr MorSM, - SMESH::SMESH_Hypothesis_ptr anHyp) +} + +void SMESHGUI_HypothesisDlg::accept() +{ + QString msg; + if ( myCreator && !myCreator->checkParams( msg ) ) { - SALOMEDS::SObject_var AHR, aRef; - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::AttributeIOR_var anIOR; - int res = SMESH::HYP_UNKNOWN_FATAL; - QAD_WaitCursor wc; - - if (!MorSM->_is_nil()) { - try { - GEOM::GEOM_Object_var aShapeObject = SMESH::GetShapeOnMeshOrSubMesh(MorSM); - if (!aShapeObject->_is_nil()) { - SMESH::SMESH_Mesh_var aMesh = SMESH::SObjectToInterface(MorSM); - SMESH::SMESH_subMesh_var aSubMesh = SMESH::SObjectToInterface(MorSM); - - if ( !aSubMesh->_is_nil() ) - aMesh = aSubMesh->GetFather(); - - if (!aMesh->_is_nil()) { - res = aMesh->RemoveHypothesis(aShapeObject, anHyp); - if ( res < SMESH::HYP_UNKNOWN_FATAL ) - SMESH::ModifiedMesh(MorSM, false); - if ( res > SMESH::HYP_OK ) { - wc.stop(); - processHypothesisStatus( res, anHyp, this, false ); - wc.start(); - } - } - } - } catch( const SALOME::SALOME_Exception& S_ex ) { - wc.stop(); - QtCatchCorbaException( S_ex ); - res = SMESH::HYP_UNKNOWN_FATAL; - } - } - return res < SMESH::HYP_UNKNOWN_FATAL; + QString str( tr( "SMESH_INCORRECT_INPUT" ) ); + if ( !msg.isEmpty() ) + str += "\n" + msg; + SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str ); + return; } + QtxDialog::accept(); +} - SALOMEDS::Study::ListOfSObject* GetMeshesUsingAlgoOrHypothesis( SMESH::SMESH_Hypothesis_ptr AlgoOrHyp ) - { - SALOMEDS::Study::ListOfSObject_var listSOmesh = - new SALOMEDS::Study::ListOfSObject; - listSOmesh->length(0); - unsigned int index = 0; - if (!AlgoOrHyp->_is_nil()) { - SALOMEDS::SObject_var SO_Hypothesis = SMESH::FindSObject(AlgoOrHyp); - if (!SO_Hypothesis->_is_nil()) { - SALOMEDS::Study::ListOfSObject_var listSO = - smeshGUI->myStudy->FindDependances(SO_Hypothesis); - if(MYDEBUG) MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): dependency number ="<length()); - for (unsigned int i = 0; i < listSO->length(); i++) { - SALOMEDS::SObject_ptr SO = listSO[i]; - if (!SO->_is_nil()) { - SALOMEDS::SObject_var aFather = SO->GetFather(); - if (!aFather->_is_nil()) { - SALOMEDS::SObject_var SOfatherFather = aFather->GetFather(); - if (!SOfatherFather->_is_nil()) { - if(MYDEBUG) MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): dependency added to list"); - index++; - listSOmesh->length(index); - listSOmesh[index - 1] = SOfatherFather; - } - } - } - } +void SMESHGUI_HypothesisDlg::reject() +{ + if ( myCreator ) myCreator->onReject(); + QtxDialog::reject(); +} + +void SMESHGUI_HypothesisDlg::onHelp() +{ + LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication()); + if (app) { + QString name = "SMESH"; + if(myCreator) { + QVariant pluginName = myCreator->property( SMESH::Plugin_Name() ); + if( pluginName.isValid() ) { + QString rootDir = pluginName.toString() + "PLUGIN_ROOT_DIR"; + QString varValue = QString( getenv(rootDir.toLatin1().constData())); + if(!varValue.isEmpty()) + name = pluginName.toString() + "PLUGIN"; } - } - if(MYDEBUG) MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): completed"); - return listSOmesh._retn(); + } + app->onHelpContextModule(name, myHelpFileName); + } + else { + QString platform; +#ifdef WIN32 + platform = "winapplication"; +#else + platform = "application"; +#endif + SUIT_MessageBox::warning(this, tr("WRN_WARNING"), + tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE"). + arg(app->resourceMgr()->stringValue("ExternalBrowser", + platform)). + arg(myHelpFileName)); } +} + +void SMESHGUI_HypothesisDlg::setHIcon( const QPixmap& p ) +{ + myIconLabel->setPixmap( p ); +} + +void SMESHGUI_HypothesisDlg::setType( const QString& t ) +{ + myTypeLabel->setText( t ); +} +HypothesisData::HypothesisData( const QString& theTypeName, + const QString& thePluginName, + const QString& theServerLibName, + const QString& theClientLibName, + const QString& theLabel, + const QString& theIconId, + const QString& theContext, + const QList& theDim, + const bool theIsAuxOrNeedHyp, + const QStringList& theBasicHypos, + const QStringList& theOptionalHypos, + const QStringList& theInputTypes, + const QStringList& theOutputTypes, + const bool theIsNeedGeometry, + const bool supportSub) + : TypeName( theTypeName ), + PluginName( thePluginName ), + ServerLibName( theServerLibName ), + ClientLibName( theClientLibName ), + Label( theLabel ), + IconId( theIconId ), + Context( theContext ), + Dim( theDim ), + IsAuxOrNeedHyp( theIsAuxOrNeedHyp ), + BasicHypos( theBasicHypos ), + OptionalHypos( theOptionalHypos ), + InputTypes( theInputTypes ), + OutputTypes( theOutputTypes ), + IsNeedGeometry( theIsNeedGeometry ), + IsSupportSubmeshes( supportSub ) +{ +} + +HypothesesSet::HypothesesSet( const QString& theSetName ) + : myHypoSetName( theSetName ), + myIsAlgo( false ), + myIsCustom( false ) +{ +} + +HypothesesSet::HypothesesSet( const QString& theSetName, + const QStringList& theHypoList, + const QStringList& theAlgoList ) + : myHypoSetName( theSetName ), + myHypoList( theHypoList ), + myAlgoList( theAlgoList ), + myIsAlgo( false ), + myIsCustom( false ) +{ +} + +QStringList* HypothesesSet::list(bool is_algo) const +{ + return const_cast( &( is_algo ? myAlgoList : myHypoList ) ); +} + +QStringList* HypothesesSet::list() const +{ + return list( myIsAlgo ); +} + +QString HypothesesSet::name() const +{ + return myHypoSetName; +} + +void HypothesesSet::set( bool isAlgo, const QStringList& lst ) +{ + *list(isAlgo) = lst; +} + +int HypothesesSet::count( bool isAlgo ) const +{ + return list(isAlgo)->count(); +} + +bool HypothesesSet::isAlgo() const +{ + return myIsAlgo; +} + +void HypothesesSet::init( bool isAlgo ) +{ + myIsAlgo = isAlgo; + myIndex = -1; +} + +bool HypothesesSet::more() const +{ + return myIndex < list()->count(); +} + +void HypothesesSet::next() +{ + myIndex++; +} + +QString HypothesesSet::current() const +{ + return list()->at(myIndex); +} + +void HypothesesSet::setIsCustom( bool isCustom ) +{ + myIsCustom = isCustom; +} + +bool HypothesesSet::getIsCustom() const +{ + return myIsCustom; +} + +int HypothesesSet::maxDim() const +{ + HypothesesSet * thisSet = (HypothesesSet*) this; + int dim = -1; + for ( int isAlgo = 0; isAlgo < 2; ++isAlgo ) + { + thisSet->init( isAlgo ); + while ( thisSet->next(), thisSet->more() ) + if ( HypothesisData* hypData = SMESH::GetHypothesisData( thisSet->current() )) + for ( int i = 0; i < hypData->Dim.count(); ++i ) + dim = qMax( dim, hypData->Dim[i] ); + } + return dim; }