X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FStdMeshersGUI%2FStdMeshersGUI_StdHypothesisCreator.cxx;h=8fd24f3510ec063b15f3fff65dcbc086f212bed2;hb=6650dea1f85dd5c640829d6e0391d703a304a152;hp=b92bdeac918a32f53e0d3b3a72ca3573f34770a8;hpb=79b1ac2b6df9117f16f11d444b1f165d477a1813;p=modules%2Fsmesh.git diff --git a/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx b/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx index b92bdeac9..8fd24f351 100644 --- a/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx +++ b/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx @@ -1,52 +1,56 @@ -// SMESH StdMeshersGUI : GUI for plugged-in meshers +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE // -// Copyright (C) 2003 CEA -// -// 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.salome-platform.org/ or email : webmaster.salome@opencascade.com +// 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. // +// 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 : StdMeshersGUI_StdHypothesisCreator.cxx -// Author : Alexander SOLOVYOV -// Module : SMESH -// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx +// File : StdMeshersGUI_StdHypothesisCreator.cxx +// Author : Alexander SOLOVYOV, Open CASCADE S.A.S. +// SMESH includes +// #include "StdMeshersGUI_StdHypothesisCreator.h" -#include "SMESHGUI.h" -#include "SMESHGUI_SpinBox.h" -#include "SMESHGUI_HypothesesUtils.h" -#include "SMESHGUI_Utils.h" -#include "SMESH_TypeFilter.hxx" -#include "SMESH_NumberFilter.hxx" +#include +#include +#include +#include +#include +#include #include "StdMeshersGUI_ObjectReferenceParamWdg.h" #include "StdMeshersGUI_LayerDistributionParamWdg.h" +#include "StdMeshersGUI_SubShapeSelectorWdg.h" +#include "StdMeshersGUI_FixedPointsParamWdg.h" +#include -#include "SUIT_ResourceMgr.h" +// SALOME GUI includes +#include +// IDL includes #include #include CORBA_SERVER_HEADER(SMESH_BasicHypothesis) #include CORBA_SERVER_HEADER(SMESH_Mesh) -#include -#include -#include -#include - +// Qt includes +#include +#include +#include +#include const double VALUE_MAX = 1.0e+15, // COORD_MAX VALUE_MAX_2 = VALUE_MAX * VALUE_MAX, @@ -91,16 +95,16 @@ QWidget* StdMeshersGUI_StdHypothesisCreator::getWidgetForParam( int i ) const if ( isCreation() ) ++i; // skip widget of 'name' parameter if ( i < myCustomWidgets.count() ) { - QPtrList::const_iterator anIt = myCustomWidgets.begin(); - QPtrList::const_iterator aLast = myCustomWidgets.end(); - for ( int j = 0 ; !w && anIt != aLast; ++anIt ) + QList::const_iterator anIt = myCustomWidgets.begin(); + QList::const_iterator aLast = myCustomWidgets.end(); + for ( int j = 0 ; !w && anIt != aLast; ++anIt, ++j ) if ( i == j ) w = *anIt; } if ( !w ) { // list has no at() const, so we iterate - QPtrList::const_iterator anIt = widgets().begin(); - QPtrList::const_iterator aLast = widgets().end(); + QList::const_iterator anIt = widgets().begin(); + QList::const_iterator aLast = widgets().end(); for( int j = 0; !w && anIt!=aLast; anIt++, ++j ) { if ( i == j ) w = *anIt; @@ -170,6 +174,9 @@ void StdMeshersGUI_StdHypothesisCreator::retrieveParams() const if ( widgetToActivate ) widgetToActivate->activateSelection(); } + + if ( dlg() ) + dlg()->setMinimumSize( dlg()->minimumSizeHint().width(), dlg()->minimumSizeHint().height() ); } namespace { @@ -180,20 +187,37 @@ namespace { */ //================================================================================ - class TDoubleSliderWith2Lables: public QHBox + class TDoubleSliderWith2Lables: public QWidget { public: TDoubleSliderWith2Lables( const QString& leftLabel, const QString& rightLabel, const double initValue, const double bottom, const double top , const double precision, QWidget * parent=0 , const char * name=0 ) - :QHBox(parent,name), _bottom(bottom), _precision(precision) + :QWidget(parent), _bottom(bottom), _precision(precision) { - if ( !leftLabel.isEmpty() ) (new QLabel( this ))->setText( leftLabel ); - _slider = new QSlider( Horizontal, this ); + setObjectName(name); + + QHBoxLayout* aHBoxL = new QHBoxLayout(this); + + if ( !leftLabel.isEmpty() ) { + QLabel* aLeftLabel = new QLabel( this ); + aLeftLabel->setText( leftLabel ); + aHBoxL->addWidget( aLeftLabel ); + } + + _slider = new QSlider( Qt::Horizontal, this ); _slider->setRange( 0, toInt( top )); _slider->setValue( toInt( initValue )); - if ( !rightLabel.isEmpty() ) (new QLabel( this ))->setText( rightLabel ); + aHBoxL->addWidget( _slider ); + + if ( !rightLabel.isEmpty() ) { + QLabel* aRightLabel = new QLabel( this ); + aRightLabel->setText( rightLabel ); + aHBoxL->addWidget( aRightLabel ); + } + + setLayout( aHBoxL ); } double value() const { return _bottom + _slider->value() * _precision; } QSlider * getSlider() const { return _slider; } @@ -298,11 +322,11 @@ namespace { */ //================================================================================ - void deactivateObjRefParamWdg( QPtrList* widgetList ) + void deactivateObjRefParamWdg( QList* widgetList ) { StdMeshersGUI_ObjectReferenceParamWdg* w = 0; - QPtrList::iterator anIt = widgetList->begin(); - QPtrList::iterator aLast = widgetList->end(); + QList::iterator anIt = widgetList->begin(); + QList::iterator aLast = widgetList->end(); for ( ; anIt != aLast; anIt++ ) { if ( (*anIt) && (*anIt)->inherits( "StdMeshersGUI_ObjectReferenceParamWdg" )) { @@ -320,8 +344,11 @@ namespace { */ //================================================================================ -bool StdMeshersGUI_StdHypothesisCreator::checkParams() const +bool StdMeshersGUI_StdHypothesisCreator::checkParams( QString& msg ) const { + if( !SMESHGUI_GenericHypothesisCreator::checkParams( msg ) ) + return false; + // check if object reference parameter is set, as it has no default value bool ok = true; if ( hypType().startsWith("ProjectionSource" )) @@ -352,12 +379,18 @@ bool StdMeshersGUI_StdHypothesisCreator::checkParams() const if ( ok ) deactivateObjRefParamWdg( customWidgets() ); } - else if ( hypType() == "LayerDistribution" ) + else if ( hypType() == "LayerDistribution" || hypType() == "LayerDistribution2D" ) { StdMeshersGUI_LayerDistributionParamWdg* w = widget< StdMeshersGUI_LayerDistributionParamWdg >( 0 ); ok = ( w && w->IsOk() ); } + else if ( hypType() == "QuadrangleParams" ) + { + StdMeshersGUI_SubShapeSelectorWdg* w = + widget< StdMeshersGUI_SubShapeSelectorWdg >( 0 ); + ok = ( w->GetListSize() > 0 ); + } return ok; } @@ -374,93 +407,173 @@ QString StdMeshersGUI_StdHypothesisCreator::storeParams() const bool res = getStdParamFromDlg( params ); if( isCreation() ) { - SMESH::SetName( SMESH::FindSObject( hypothesis() ), params[0].myValue.toString().latin1() ); - params.remove( params.begin() ); + SMESH::SetName( SMESH::FindSObject( hypothesis() ), params[0].myValue.toString().toLatin1().data() ); + params.erase( params.begin() ); } QString valueStr = stdParamValues( params ); + QStringList aVariablesList = getVariablesFromDlg(); if( res && !params.isEmpty() ) { if( hypType()=="LocalLength" ) { StdMeshers::StdMeshers_LocalLength_var h = - StdMeshers::StdMeshers_LocalLength::_narrow( hypothesis() ); + StdMeshers::StdMeshers_LocalLength::_narrow( hypothesis() ); h->SetLength( params[0].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); h->SetPrecision( params[1].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); + } + else if( hypType()=="MaxLength" ) + { + StdMeshers::StdMeshers_MaxLength_var h = + StdMeshers::StdMeshers_MaxLength::_narrow( hypothesis() ); + + h->SetLength( params[0].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); + h->SetUsePreestimatedLength( widget< QCheckBox >( 1 )->isChecked() ); + if ( !h->HavePreestimatedLength() && !h->_is_equivalent( initParamsHypothesis() )) { + StdMeshers::StdMeshers_MaxLength_var hInit = + StdMeshers::StdMeshers_MaxLength::_narrow( initParamsHypothesis() ); + h->SetPreestimatedLength( hInit->GetPreestimatedLength() ); + } } else if( hypType()=="SegmentLengthAroundVertex" ) { StdMeshers::StdMeshers_SegmentLengthAroundVertex_var h = - StdMeshers::StdMeshers_SegmentLengthAroundVertex::_narrow( hypothesis() ); + StdMeshers::StdMeshers_SegmentLengthAroundVertex::_narrow( hypothesis() ); h->SetLength( params[0].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); } else if( hypType()=="Arithmetic1D" ) { StdMeshers::StdMeshers_Arithmetic1D_var h = - StdMeshers::StdMeshers_Arithmetic1D::_narrow( hypothesis() ); + StdMeshers::StdMeshers_Arithmetic1D::_narrow( hypothesis() ); + + StdMeshersGUI_SubShapeSelectorWdg* w = + widget< StdMeshersGUI_SubShapeSelectorWdg >( 2 ); + + h->SetStartLength( params[0].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); + h->SetEndLength( params[1].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); + if (w) { + h->SetReversedEdges( w->GetListOfIDs() ); + h->SetObjectEntry( w->GetMainShapeEntry() ); + } + } + else if( hypType()=="FixedPoints1D" ) + { + StdMeshers::StdMeshers_FixedPoints1D_var h = + StdMeshers::StdMeshers_FixedPoints1D::_narrow( hypothesis() ); + + StdMeshersGUI_FixedPointsParamWdg* w1 = + widget< StdMeshersGUI_FixedPointsParamWdg >( 0 ); - h->SetLength( params[0].myValue.toDouble(), true ); - h->SetLength( params[1].myValue.toDouble(), false ); + StdMeshersGUI_SubShapeSelectorWdg* w2 = + widget< StdMeshersGUI_SubShapeSelectorWdg >( 1 ); + + if (w1) { + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); + h->SetPoints( w1->GetListOfPoints() ); + h->SetNbSegments( w1->GetListOfSegments() ); + } + if (w2) { + h->SetReversedEdges( w2->GetListOfIDs() ); + h->SetObjectEntry( w2->GetMainShapeEntry() ); + } } else if( hypType()=="MaxElementArea" ) { StdMeshers::StdMeshers_MaxElementArea_var h = - StdMeshers::StdMeshers_MaxElementArea::_narrow( hypothesis() ); - + StdMeshers::StdMeshers_MaxElementArea::_narrow( hypothesis() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); h->SetMaxElementArea( params[0].myValue.toDouble() ); } else if( hypType()=="MaxElementVolume" ) { StdMeshers::StdMeshers_MaxElementVolume_var h = - StdMeshers::StdMeshers_MaxElementVolume::_narrow( hypothesis() ); + StdMeshers::StdMeshers_MaxElementVolume::_narrow( hypothesis() ); h->SetMaxElementVolume( params[0].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); } else if( hypType()=="StartEndLength" ) { StdMeshers::StdMeshers_StartEndLength_var h = - StdMeshers::StdMeshers_StartEndLength::_narrow( hypothesis() ); - - h->SetLength( params[0].myValue.toDouble(), true ); - h->SetLength( params[1].myValue.toDouble(), false ); + StdMeshers::StdMeshers_StartEndLength::_narrow( hypothesis() ); + + StdMeshersGUI_SubShapeSelectorWdg* w = + widget< StdMeshersGUI_SubShapeSelectorWdg >( 2 ); + + h->SetStartLength( params[0].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); + h->SetEndLength( params[1].myValue.toDouble() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); + if (w) { + h->SetReversedEdges( w->GetListOfIDs() ); + h->SetObjectEntry( w->GetMainShapeEntry() ); + } } else if( hypType()=="Deflection1D" ) { StdMeshers::StdMeshers_Deflection1D_var h = - StdMeshers::StdMeshers_Deflection1D::_narrow( hypothesis() ); - + StdMeshers::StdMeshers_Deflection1D::_narrow( hypothesis() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); h->SetDeflection( params[0].myValue.toDouble() ); } else if( hypType()=="AutomaticLength" ) { StdMeshers::StdMeshers_AutomaticLength_var h = - StdMeshers::StdMeshers_AutomaticLength::_narrow( hypothesis() ); + StdMeshers::StdMeshers_AutomaticLength::_narrow( hypothesis() ); h->SetFineness( params[0].myValue.toDouble() ); } else if( hypType()=="NumberOfLayers" ) { StdMeshers::StdMeshers_NumberOfLayers_var h = - StdMeshers::StdMeshers_NumberOfLayers::_narrow( hypothesis() ); + StdMeshers::StdMeshers_NumberOfLayers::_narrow( hypothesis() ); h->SetNumberOfLayers( params[0].myValue.toInt() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); } else if( hypType()=="LayerDistribution" ) { StdMeshers::StdMeshers_LayerDistribution_var h = - StdMeshers::StdMeshers_LayerDistribution::_narrow( hypothesis() ); + StdMeshers::StdMeshers_LayerDistribution::_narrow( hypothesis() ); StdMeshersGUI_LayerDistributionParamWdg* w = widget< StdMeshersGUI_LayerDistributionParamWdg >( 0 ); + + h->SetLayerDistribution( w->GetHypothesis() ); + h->SetParameters(w->GetHypothesis()->GetParameters()); + w->GetHypothesis()->ClearParameters(); + } + else if( hypType()=="NumberOfLayers2D" ) + { + StdMeshers::StdMeshers_NumberOfLayers2D_var h = + StdMeshers::StdMeshers_NumberOfLayers2D::_narrow( hypothesis() ); + h->SetNumberOfLayers( params[0].myValue.toInt() ); + h->SetParameters(aVariablesList.join(":").toLatin1().constData()); + } + else if( hypType()=="LayerDistribution2D" ) + { + StdMeshers::StdMeshers_LayerDistribution2D_var h = + StdMeshers::StdMeshers_LayerDistribution2D::_narrow( hypothesis() ); + StdMeshersGUI_LayerDistributionParamWdg* w = + widget< StdMeshersGUI_LayerDistributionParamWdg >( 0 ); + h->SetLayerDistribution( w->GetHypothesis() ); + h->SetParameters(w->GetHypothesis()->GetParameters()); + w->GetHypothesis()->ClearParameters(); } else if( hypType()=="ProjectionSource1D" ) { StdMeshers::StdMeshers_ProjectionSource1D_var h = - StdMeshers::StdMeshers_ProjectionSource1D::_narrow( hypothesis() ); + StdMeshers::StdMeshers_ProjectionSource1D::_narrow( hypothesis() ); h->SetSourceEdge ( geomFromWdg ( getWidgetForParam( 0 ))); h->SetSourceMesh ( meshFromWdg ( getWidgetForParam( 1 ))); @@ -470,7 +583,7 @@ QString StdMeshersGUI_StdHypothesisCreator::storeParams() const else if( hypType()=="ProjectionSource2D" ) { StdMeshers::StdMeshers_ProjectionSource2D_var h = - StdMeshers::StdMeshers_ProjectionSource2D::_narrow( hypothesis() ); + StdMeshers::StdMeshers_ProjectionSource2D::_narrow( hypothesis() ); h->SetSourceFace ( geomFromWdg ( getWidgetForParam( 0 ))); h->SetSourceMesh ( meshFromWdg ( getWidgetForParam( 1 ))); @@ -482,7 +595,7 @@ QString StdMeshersGUI_StdHypothesisCreator::storeParams() const else if( hypType()=="ProjectionSource3D" ) { StdMeshers::StdMeshers_ProjectionSource3D_var h = - StdMeshers::StdMeshers_ProjectionSource3D::_narrow( hypothesis() ); + StdMeshers::StdMeshers_ProjectionSource3D::_narrow( hypothesis() ); h->SetSource3DShape ( geomFromWdg ( getWidgetForParam( 0 ))); h->SetSourceMesh ( meshFromWdg ( getWidgetForParam( 1 ))); @@ -491,6 +604,20 @@ QString StdMeshersGUI_StdHypothesisCreator::storeParams() const geomFromWdg ( getWidgetForParam( 3 )), // tgt1 geomFromWdg ( getWidgetForParam( 5 ))); // tgt2 } + else if( hypType()=="QuadrangleParams" ) + { + StdMeshers::StdMeshers_QuadrangleParams_var h = + StdMeshers::StdMeshers_QuadrangleParams::_narrow( hypothesis() ); + StdMeshersGUI_SubShapeSelectorWdg* w = + widget< StdMeshersGUI_SubShapeSelectorWdg >( 0 ); + if (w) { + if( w->GetListSize() > 0 ) { + h->SetTriaVertex( w->GetListOfIDs()[0] ); // getlist must be called once + const char * entry = w->GetMainShapeEntry(); + h->SetObjectEntry( entry ); + } + } + } } return valueStr; } @@ -525,20 +652,59 @@ bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const p.append( item ); customWidgets()->append(0); } - + SMESH::SMESH_Hypothesis_var hyp = initParamsHypothesis(); + SMESH::ListOfParameters_var aParameters = hyp->GetLastParameters(); if( hypType()=="LocalLength" ) { StdMeshers::StdMeshers_LocalLength_var h = StdMeshers::StdMeshers_LocalLength::_narrow( hyp ); + + item.myName = tr("SMESH_LOCAL_LENGTH_PARAM"); + if(!initVariableName(aParameters,item,0)) + item.myValue = h->GetLength(); + p.append( item ); + + item.myName = tr("SMESH_LOCAL_LENGTH_PRECISION"); + if(!initVariableName(aParameters,item,1)) + item.myValue = h->GetPrecision(); + p.append( item ); + + } + else if( hypType()=="MaxLength" ) + { + StdMeshers::StdMeshers_MaxLength_var h = + StdMeshers::StdMeshers_MaxLength::_narrow( hyp ); + // try to set a right preestimated length to edited hypothesis + bool noPreestimatedAtEdition = false; + if ( !isCreation() ) { + StdMeshers::StdMeshers_MaxLength_var initHyp = + StdMeshers::StdMeshers_MaxLength::_narrow( initParamsHypothesis(true) ); + noPreestimatedAtEdition = + ( initHyp->_is_nil() || !initHyp->HavePreestimatedLength() ); + if ( !noPreestimatedAtEdition ) + h->SetPreestimatedLength( initHyp->GetPreestimatedLength() ); + } item.myName = tr("SMESH_LOCAL_LENGTH_PARAM"); - item.myValue = h->GetLength(); + if(!initVariableName(aParameters,item,0)) + item.myValue = h->GetLength(); p.append( item ); - item.myName = tr("SMESH_LOCAL_LENGTH_PRECISION"); - item.myValue = h->GetPrecision(); + customWidgets()->append(0); + + item.myName = tr("SMESH_USE_PREESTIMATED_LENGTH"); p.append( item ); + QCheckBox* aQCheckBox = new QCheckBox(dlg()); + if ( !noPreestimatedAtEdition && h->HavePreestimatedLength() ) { + aQCheckBox->setChecked( h->GetUsePreestimatedLength() ); + connect( aQCheckBox, SIGNAL( stateChanged(int) ), this, SLOT( onValueChanged() ) ); + } + else { + aQCheckBox->setChecked( false ); + aQCheckBox->setEnabled( false ); + } + customWidgets()->append( aQCheckBox ); } else if( hypType()=="SegmentLengthAroundVertex" ) { @@ -546,7 +712,9 @@ bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const StdMeshers::StdMeshers_SegmentLengthAroundVertex::_narrow( hyp ); item.myName = tr("SMESH_LOCAL_LENGTH_PARAM"); - item.myValue = h->GetLength(); + if(!initVariableName(aParameters,item,0)) + item.myValue = h->GetLength(); + p.append( item ); } else if( hypType()=="Arithmetic1D" ) @@ -555,20 +723,81 @@ bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const StdMeshers::StdMeshers_Arithmetic1D::_narrow( hyp ); item.myName = tr( "SMESH_START_LENGTH_PARAM" ); - item.myValue = h->GetLength( true ); + if(!initVariableName(aParameters,item,0)) + item.myValue = h->GetLength( true ); p.append( item ); + + customWidgets()->append (0); + item.myName = tr( "SMESH_END_LENGTH_PARAM" ); - item.myValue = h->GetLength( false ); + if(!initVariableName(aParameters,item,1)) + item.myValue = h->GetLength( false ); + p.append( item ); + + customWidgets()->append (0); + + item.myName = tr( "SMESH_REVERSED_EDGES" ); + p.append( item ); + + StdMeshersGUI_SubShapeSelectorWdg* aDirectionWidget = + new StdMeshersGUI_SubShapeSelectorWdg(); + QString aGeomEntry = SMESHGUI_GenericHypothesisCreator::getShapeEntry(); + QString aMainEntry = SMESHGUI_GenericHypothesisCreator::getMainShapeEntry(); + if ( aGeomEntry == "" ) + aGeomEntry = h->GetObjectEntry(); + + aDirectionWidget->SetGeomShapeEntry( aGeomEntry ); + aDirectionWidget->SetMainShapeEntry( aMainEntry ); + aDirectionWidget->SetListOfIDs( h->GetReversedEdges() ); + aDirectionWidget->showPreview( true ); + customWidgets()->append ( aDirectionWidget ); + } + + + else if( hypType()=="FixedPoints1D" ) + { + StdMeshers::StdMeshers_FixedPoints1D_var h = + StdMeshers::StdMeshers_FixedPoints1D::_narrow( hyp ); + + item.myName = tr( "SMESH_FIXED_POINTS" ); p.append( item ); + + StdMeshersGUI_FixedPointsParamWdg* aFixedPointsWidget = + new StdMeshersGUI_FixedPointsParamWdg(); + + if ( !isCreation() ) { + aFixedPointsWidget->SetListOfPoints( h->GetPoints() ); + aFixedPointsWidget->SetListOfSegments( h->GetNbSegments() ); + } + customWidgets()->append( aFixedPointsWidget ); + + item.myName = tr( "SMESH_REVERSED_EDGES" ); + p.append( item ); + + StdMeshersGUI_SubShapeSelectorWdg* aDirectionWidget = + new StdMeshersGUI_SubShapeSelectorWdg(); + QString anEntry = SMESHGUI_GenericHypothesisCreator::getShapeEntry(); + QString aMainEntry = SMESHGUI_GenericHypothesisCreator::getMainShapeEntry(); + if ( anEntry == "" ) + anEntry = h->GetObjectEntry(); + aDirectionWidget->SetGeomShapeEntry( anEntry ); + aDirectionWidget->SetMainShapeEntry( aMainEntry ); + aDirectionWidget->SetListOfIDs( h->GetReversedEdges() ); + aDirectionWidget->showPreview( true ); + customWidgets()->append ( aDirectionWidget ); } + + else if( hypType()=="MaxElementArea" ) { StdMeshers::StdMeshers_MaxElementArea_var h = StdMeshers::StdMeshers_MaxElementArea::_narrow( hyp ); item.myName = tr( "SMESH_MAX_ELEMENT_AREA_PARAM" ); - item.myValue = h->GetMaxElementArea(); + if(!initVariableName(aParameters,item,0)) + item.myValue = h->GetMaxElementArea(); p.append( item ); + } else if( hypType()=="MaxElementVolume" ) { @@ -576,7 +805,8 @@ bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const StdMeshers::StdMeshers_MaxElementVolume::_narrow( hyp ); item.myName = tr( "SMESH_MAX_ELEMENT_VOLUME_PARAM" ); - item.myValue = h->GetMaxElementVolume(); + if(!initVariableName(aParameters,item,0)) + item.myValue = h->GetMaxElementVolume(); p.append( item ); } else if( hypType()=="StartEndLength" ) @@ -585,19 +815,41 @@ bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const StdMeshers::StdMeshers_StartEndLength::_narrow( hyp ); item.myName = tr( "SMESH_START_LENGTH_PARAM" ); - item.myValue = h->GetLength( true ); + + if(!initVariableName(aParameters,item,0)) + item.myValue = h->GetLength( true ); p.append( item ); + customWidgets()->append(0); + item.myName = tr( "SMESH_END_LENGTH_PARAM" ); - item.myValue = h->GetLength( false ); + if(!initVariableName(aParameters,item,1)) + item.myValue = h->GetLength( false ); + p.append( item ); + customWidgets()->append(0); + + item.myName = tr( "SMESH_REVERSED_EDGES" ); p.append( item ); + + StdMeshersGUI_SubShapeSelectorWdg* aDirectionWidget = + new StdMeshersGUI_SubShapeSelectorWdg(); + QString anEntry = SMESHGUI_GenericHypothesisCreator::getShapeEntry(); + QString aMainEntry = SMESHGUI_GenericHypothesisCreator::getMainShapeEntry(); + if ( anEntry == "" ) + anEntry = h->GetObjectEntry(); + aDirectionWidget->SetGeomShapeEntry( anEntry ); + aDirectionWidget->SetMainShapeEntry( aMainEntry ); + aDirectionWidget->SetListOfIDs( h->GetReversedEdges() ); + aDirectionWidget->showPreview( true ); + customWidgets()->append ( aDirectionWidget ); } else if( hypType()=="Deflection1D" ) { StdMeshers::StdMeshers_Deflection1D_var h = StdMeshers::StdMeshers_Deflection1D::_narrow( hyp ); - + item.myName = tr( "SMESH_DEFLECTION1D_PARAM" ); - item.myValue = h->GetDeflection(); + if(!initVariableName(aParameters,item,0)) + item.myValue = h->GetDeflection(); p.append( item ); } else if( hypType()=="AutomaticLength" ) @@ -617,15 +869,50 @@ bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const StdMeshers::StdMeshers_NumberOfLayers::_narrow( hyp ); item.myName = tr( "SMESH_NUMBER_OF_LAYERS" ); - item.myValue = (int) h->GetNumberOfLayers(); + if(!initVariableName(aParameters,item,0)) + item.myValue = (int) h->GetNumberOfLayers(); p.append( item ); } - else if( hypType()=="LayerDistribution" ) - { + else if( hypType()=="LayerDistribution" ) { StdMeshers::StdMeshers_LayerDistribution_var h = StdMeshers::StdMeshers_LayerDistribution::_narrow( hyp ); + + item.myName = tr( "SMESH_LAYERS_DISTRIBUTION" ); p.append( item ); + + //Set into not published hypo last variables + QStringList aLastVarsList; + for(int i = 0;ilength();i++) + aLastVarsList.append(QString(aParameters[i].in())); + + if(!aLastVarsList.isEmpty()) + h->GetLayerDistribution()->SetLastParameters(aLastVarsList.join(":").toLatin1().constData()); + + customWidgets()->append + ( new StdMeshersGUI_LayerDistributionParamWdg( h->GetLayerDistribution(), hypName(), dlg())); + } + else if( hypType()=="NumberOfLayers2D" ) { + StdMeshers::StdMeshers_NumberOfLayers2D_var h = + StdMeshers::StdMeshers_NumberOfLayers2D::_narrow( hyp ); + + item.myName = tr( "SMESH_NUMBER_OF_LAYERS" ); + if(!initVariableName(aParameters,item,0)) + item.myValue = (int) h->GetNumberOfLayers(); + p.append( item ); + } + else if( hypType()=="LayerDistribution2D" ) { + StdMeshers::StdMeshers_LayerDistribution2D_var h = + StdMeshers::StdMeshers_LayerDistribution2D::_narrow( hyp ); item.myName = tr( "SMESH_LAYERS_DISTRIBUTION" ); p.append( item ); + + //Set into not published hypo last variables + QStringList aLastVarsList; + for(int i = 0;ilength();i++) + aLastVarsList.append(QString(aParameters[i].in())); + + if(!aLastVarsList.isEmpty()) + h->GetLayerDistribution()->SetLastParameters(aLastVarsList.join(":").toLatin1().constData()); + customWidgets()->append ( new StdMeshersGUI_LayerDistributionParamWdg( h->GetLayerDistribution(), hypName(), dlg())); } @@ -695,6 +982,36 @@ bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ), h->GetTargetVertex( 2 ))); } + else if( hypType()=="QuadrangleParams" ) + { + StdMeshers::StdMeshers_QuadrangleParams_var h = + StdMeshers::StdMeshers_QuadrangleParams::_narrow( hyp ); + + item.myName = tr( "SMESH_BASE_VERTEX" ); + p.append( item ); + + StdMeshersGUI_SubShapeSelectorWdg* aDirectionWidget = + new StdMeshersGUI_SubShapeSelectorWdg(); + aDirectionWidget->SetMaxSize(1); + aDirectionWidget->SetSubShType(TopAbs_VERTEX); + QString anEntry = SMESHGUI_GenericHypothesisCreator::getShapeEntry(); + QString aMainEntry = SMESHGUI_GenericHypothesisCreator::getMainShapeEntry(); + if ( anEntry == "" ) + anEntry = h->GetObjectEntry(); + aDirectionWidget->SetGeomShapeEntry( anEntry ); + aDirectionWidget->SetMainShapeEntry( aMainEntry ); + if ( !isCreation() ) { + SMESH::long_array_var aVec = new SMESH::long_array; + int vertID = h->GetTriaVertex(); + if(vertID>0) { + aVec->length(1); + aVec[0] = vertID; + aDirectionWidget->SetListOfIDs( aVec ); + } + } + aDirectionWidget->showPreview( true ); + customWidgets()->append ( aDirectionWidget ); + } else res = false; return res; @@ -713,34 +1030,39 @@ void StdMeshersGUI_StdHypothesisCreator::attuneStdWidget (QWidget* w, const int) SMESHGUI_SpinBox* sb = w->inherits( "SMESHGUI_SpinBox" ) ? ( SMESHGUI_SpinBox* )w : 0; if( hypType()=="LocalLength" && sb ) { - if (sb->name() == tr("SMESH_LOCAL_LENGTH_PARAM")) - sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, 6 ); - else if (sb->name() == tr("SMESH_LOCAL_LENGTH_PRECISION")) - sb->RangeStepAndValidator( 0.0, 1.0, 0.05, 6 ); + if (sb->objectName() == tr("SMESH_LOCAL_LENGTH_PARAM")) + sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" ); + else if (sb->objectName() == tr("SMESH_LOCAL_LENGTH_PRECISION")) + sb->RangeStepAndValidator( 0.0, 1.0, 0.05, "len_tol_precision" ); } else if( hypType()=="Arithmetic1D" && sb ) { - sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, 6 ); + sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "parametric_precision" ); + } + else if( hypType()=="MaxLength" && sb ) + { + sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" ); + sb->setEnabled( !widget< QCheckBox >( 1 )->isChecked() ); } else if( hypType()=="MaxElementArea" && sb ) { - sb->RangeStepAndValidator( VALUE_SMALL_2, VALUE_MAX_2, 1.0, 6 ); + sb->RangeStepAndValidator( VALUE_SMALL_2, VALUE_MAX_2, 1.0, "area_precision" ); } else if( hypType()=="MaxElementVolume" && sb ) { - sb->RangeStepAndValidator( VALUE_SMALL_3, VALUE_MAX_3, 1.0, 6 ); + sb->RangeStepAndValidator( VALUE_SMALL_3, VALUE_MAX_3, 1.0, "vol_precision" ); } else if( hypType()=="StartEndLength" && sb ) { - sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, 6 ); + sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" ); } else if( hypType()=="Deflection1D" && sb ) { - sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, 6 ); + sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "parametric_precision" ); } else if ( sb ) // default validator for possible ancestors { - sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, 6 ); + sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" ); } } @@ -753,7 +1075,7 @@ void StdMeshersGUI_StdHypothesisCreator::attuneStdWidget (QWidget* w, const int) QString StdMeshersGUI_StdHypothesisCreator::caption() const { - return tr( QString( "SMESH_%1_TITLE" ).arg( hypTypeName( hypType() ) ) ); + return tr( QString( "SMESH_%1_TITLE" ).arg( hypTypeName( hypType() ) ).toLatin1().data() ); } //================================================================================ @@ -765,7 +1087,7 @@ QString StdMeshersGUI_StdHypothesisCreator::caption() const QPixmap StdMeshersGUI_StdHypothesisCreator::icon() const { - QString hypIconName = tr( QString( "ICON_DLG_%1" ).arg( hypTypeName( hypType() ) ) ); + QString hypIconName = tr( QString( "ICON_DLG_%1" ).arg( hypTypeName( hypType() ) ).toLatin1().data() ); return SMESHGUI::resourceMgr()->loadPixmap( "SMESH", hypIconName ); } @@ -778,7 +1100,7 @@ QPixmap StdMeshersGUI_StdHypothesisCreator::icon() const QString StdMeshersGUI_StdHypothesisCreator::type() const { - return tr( QString( "SMESH_%1_HYPOTHESIS" ).arg( hypTypeName( hypType() ) ) ); + return tr( QString( "SMESH_%1_HYPOTHESIS" ).arg( hypTypeName( hypType() ) ).toLatin1().data() ); } //================================================================================ @@ -802,13 +1124,18 @@ QString StdMeshersGUI_StdHypothesisCreator::hypTypeName( const QString& t ) cons types.insert( "StartEndLength", "START_END_LENGTH" ); types.insert( "Deflection1D", "DEFLECTION1D" ); types.insert( "Arithmetic1D", "ARITHMETIC_1D" ); + types.insert( "FixedPoints1D", "FIXED_POINTS_1D" ); types.insert( "AutomaticLength", "AUTOMATIC_LENGTH" ); types.insert( "ProjectionSource1D", "PROJECTION_SOURCE_1D" ); types.insert( "ProjectionSource2D", "PROJECTION_SOURCE_2D" ); types.insert( "ProjectionSource3D", "PROJECTION_SOURCE_3D" ); types.insert( "NumberOfLayers", "NUMBER_OF_LAYERS" ); types.insert( "LayerDistribution", "LAYER_DISTRIBUTION" ); + types.insert( "NumberOfLayers2D", "NUMBER_OF_LAYERS_2D" ); + types.insert( "LayerDistribution2D", "LAYER_DISTRIBUTION" ); types.insert( "SegmentLengthAroundVertex", "SEGMENT_LENGTH_AROUND_VERTEX" ); + types.insert( "MaxLength", "MAX_LENGTH" ); + types.insert( "QuadrangleParams", "QUADRANGLE_PARAMS" ); } QString res; @@ -831,8 +1158,10 @@ QWidget* StdMeshersGUI_StdHypothesisCreator::getCustomWidget( const StdParam & p QWidget* w = 0; if ( index < customWidgets()->count() ) { w = customWidgets()->at( index ); - if ( w ) - w->reparent( parent, QPoint( 0, 0 )); + if ( w ) { + w->setParent( parent ); + w->move( QPoint( 0, 0 ) ); + } } return w; } @@ -858,6 +1187,10 @@ bool StdMeshersGUI_StdHypothesisCreator::getParamFromCustomWidget( StdParam & pa return true; } } + if ( hypType() == "MaxLength" ) { + param.myValue = ""; + return true; + } if ( widget->inherits( "StdMeshersGUI_ObjectReferenceParamWdg" )) { // show only 1st reference value @@ -875,6 +1208,20 @@ bool StdMeshersGUI_StdHypothesisCreator::getParamFromCustomWidget( StdParam & pa param.myValue = w->GetValue(); return true; } + if ( widget->inherits( "StdMeshersGUI_SubShapeSelectorWdg" )) + { + const StdMeshersGUI_SubShapeSelectorWdg * w = + static_cast( widget ); + param.myValue = w->GetValue(); + return true; + } + if ( widget->inherits( "StdMeshersGUI_FixedPointsParamWdg" )) + { + const StdMeshersGUI_FixedPointsParamWdg * w = + static_cast( widget ); + param.myValue = w->GetValue(); + return true; + } return false; } @@ -892,3 +1239,39 @@ void StdMeshersGUI_StdHypothesisCreator::onReject() deactivateObjRefParamWdg( customWidgets() ); } } + +//================================================================================ +/*! + * \brief + */ +//================================================================================ + +void StdMeshersGUI_StdHypothesisCreator::valueChanged( QWidget* paramWidget) +{ + if ( hypType() == "MaxLength" && paramWidget == getWidgetForParam(1) ) { + getWidgetForParam(0)->setEnabled( !widget< QCheckBox >( 1 )->isChecked() ); + if ( !getWidgetForParam(0)->isEnabled() ) { + StdMeshers::StdMeshers_MaxLength_var h = + StdMeshers::StdMeshers_MaxLength::_narrow( initParamsHypothesis() ); + widget< QtxDoubleSpinBox >( 0 )->setValue( h->GetPreestimatedLength() ); + } + } +} + +//================================================================================ +/*! + * + */ +//================================================================================ + +bool StdMeshersGUI_StdHypothesisCreator::initVariableName(SMESH::ListOfParameters_var theParameters, + StdParam &theParams, + int order) const +{ + QString aVaribaleName = (theParameters->length() > order) ? QString(theParameters[order].in()) : QString(""); + theParams.isVariable = !aVaribaleName.isEmpty(); + if(theParams.isVariable) + theParams.myValue = aVaribaleName; + + return theParams.isVariable; +}