Salome HOME
#24666 [CEA][Windows] BLSURPLUGIN compilation issue
[modules/smesh.git] / src / StdMeshersGUI / StdMeshersGUI_StdHypothesisCreator.cxx
1 // Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 //  File   : StdMeshersGUI_StdHypothesisCreator.cxx
23 //  Author : Alexander SOLOVYOV, Open CASCADE S.A.S.
24 //  SMESH includes
25
26 #include "StdMeshersGUI_StdHypothesisCreator.h"
27
28 #include <SMESHGUI.h>
29 #include <SMESHGUI_SpinBox.h>
30 #include <SMESHGUI_HypothesesUtils.h>
31 #include <SMESHGUI_Utils.h>
32 #include <SMESHGUI_GEOMGenUtils.h>
33 #include <SMESH_TypeFilter.hxx>
34 #include <SMESH_NumberFilter.hxx>
35
36 #include "StdMeshersGUI_FixedPointsParamWdg.h"
37 #include "StdMeshersGUI_LayerDistributionParamWdg.h"
38 #include "StdMeshersGUI_ObjectReferenceParamWdg.h"
39 #include "StdMeshersGUI_PropagationHelperWdg.h"
40 #include "StdMeshersGUI_QuadrangleParamWdg.h"
41 #include "StdMeshersGUI_RadioButtonsGrpWdg.h"
42 #include "StdMeshersGUI_NameCheckableGrpWdg.h"
43 #include "StdMeshersGUI_SubShapeSelectorWdg.h"
44
45 #include <SALOMEDSClient_Study.hxx>
46
47 #include <GEOM_wrap.hxx>
48
49 // SALOME GUI includes
50 #include <SUIT_MessageBox.h>
51 #include <SUIT_ResourceMgr.h>
52 #include <SalomeApp_IntSpinBox.h>
53
54 // IDL includes
55 #include <SALOMEconfig.h>
56 #include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
57 #include CORBA_SERVER_HEADER(SMESH_Mesh)
58 #include CORBA_SERVER_HEADER(SMESH_Group)
59
60 // Qt includes
61 #include <QHBoxLayout>
62 #include <QSlider>
63 #include <QLabel>
64 #include <QCheckBox>
65 #include <QButtonGroup>
66
67 const double VALUE_MAX = 1.0e+15, // COORD_MAX
68              VALUE_MAX_2  = VALUE_MAX * VALUE_MAX,
69              VALUE_MAX_3  = VALUE_MAX_2 * VALUE_MAX,
70              VALUE_SMALL = 1.0e-15,
71              VALUE_SMALL_2 = VALUE_SMALL * VALUE_SMALL,
72              VALUE_SMALL_3 = VALUE_SMALL_2 * VALUE_SMALL;
73
74 //================================================================================
75 /*!
76  * \brief Constructor
77   * \param type - hypothesis type
78  */
79 //================================================================================
80
81 StdMeshersGUI_StdHypothesisCreator::StdMeshersGUI_StdHypothesisCreator( const QString& type )
82   : SMESHGUI_GenericHypothesisCreator( type ), myHelperWidget( 0 )
83 {
84 }
85
86 //================================================================================
87 /*!
88  * \brief Destructor
89  */
90 //================================================================================
91
92 StdMeshersGUI_StdHypothesisCreator::~StdMeshersGUI_StdHypothesisCreator()
93 {
94 }
95
96 //================================================================================
97 /*!
98  * \brief Return widget for i-th hypothesis parameter (got from myParamWidgets)
99   * \param i - index of hypothesis parameter
100   * \retval QWidget* - found widget
101  */
102 //================================================================================
103
104 QWidget* StdMeshersGUI_StdHypothesisCreator::getWidgetForParam( int i ) const
105 {
106   QWidget* w = 0;
107   if ( isCreation() ) ++i; // skip widget of 'name' parameter
108
109   if ( i < myCustomWidgets.count() ) {
110     QList<QWidget*>::const_iterator anIt  = myCustomWidgets.begin();
111     QList<QWidget*>::const_iterator aLast = myCustomWidgets.end();
112     for ( int j = 0 ; !w && anIt != aLast; ++anIt, ++j )
113       if ( i == j )
114         w = *anIt;
115   }
116   if ( !w ) {
117     // list has no at() const, so we iterate
118     QList<QWidget*>::const_iterator anIt  = widgets().begin();
119     QList<QWidget*>::const_iterator aLast = widgets().end();
120     for( int j = 0; !w && anIt!=aLast; anIt++, ++j ) {
121       if ( i == j )
122         w = *anIt;
123     }
124   }
125   return w;
126 }
127
128 //================================================================================
129 /*!
130  * \brief Allow modifying myCustomWidgets in const methods
131   * \retval ListOfWidgets* - non-const pointer to myCustomWidgets
132  */
133 //================================================================================
134
135 StdMeshersGUI_StdHypothesisCreator::ListOfWidgets*
136 StdMeshersGUI_StdHypothesisCreator::customWidgets() const
137 {
138   return const_cast< ListOfWidgets* >( & myCustomWidgets );
139 }
140
141 //================================================================================
142 /*!
143  * \brief Builds dlg layout
144   * \retval QFrame* - the built widget
145  */
146 //================================================================================
147
148 QFrame* StdMeshersGUI_StdHypothesisCreator::buildFrame()
149 {
150   return buildStdFrame();
151 }
152
153 //================================================================================
154 /*!
155  * \brief Initialise parameter values in controls
156  */
157 //================================================================================
158
159 void StdMeshersGUI_StdHypothesisCreator::retrieveParams() const
160 {
161   // buildStdFrame() sets values itself calling stdParams()
162
163   if ( hypType().startsWith("ProjectionSource" ))
164   {
165     // we use this method to connect depending custom widgets
166     StdMeshersGUI_ObjectReferenceParamWdg* widgetToActivate = 0;
167     ListOfWidgets::const_iterator anIt = myCustomWidgets.begin();
168     for ( ; anIt != myCustomWidgets.end(); anIt++)
169     {
170       if ( *anIt && (*anIt)->inherits("StdMeshersGUI_ObjectReferenceParamWdg"))
171       {
172         StdMeshersGUI_ObjectReferenceParamWdg * w1 =
173           ( StdMeshersGUI_ObjectReferenceParamWdg* ) ( *anIt );
174         ListOfWidgets::const_iterator anIt2 = anIt;
175         for ( ++anIt2; anIt2 != myCustomWidgets.end(); anIt2++)
176           if ( *anIt2 && (*anIt2)->inherits("StdMeshersGUI_ObjectReferenceParamWdg"))
177           {
178             StdMeshersGUI_ObjectReferenceParamWdg * w2 =
179               ( StdMeshersGUI_ObjectReferenceParamWdg* ) ( *anIt2 );
180             w1->AvoidSimultaneousSelection( w2 );
181           }
182         if ( !widgetToActivate )
183           widgetToActivate = w1;
184       }
185     }
186     if ( widgetToActivate )
187       widgetToActivate->activateSelection();
188   }
189
190   if ( dlg() )
191     dlg()->setMinimumSize( dlg()->minimumSizeHint().width(), dlg()->minimumSizeHint().height() );
192 }
193
194 namespace {
195
196   //================================================================================
197   /*!
198    * \brief Widget: slider with left and right labels
199    */
200   //================================================================================
201
202   class TDoubleSliderWith2Labels: public QWidget
203   {
204   public:
205     TDoubleSliderWith2Labels( const QString& leftLabel, const QString& rightLabel,
206                               const double   initValue, const double   bottom,
207                               const double   top      , const double   precision,
208                               QWidget *      parent=0 , const char *   name=0 )
209       :QWidget(parent), _bottom(bottom), _precision(precision)
210     {
211       setObjectName(name);
212
213       QHBoxLayout* aHBoxL = new QHBoxLayout(this);
214
215       if ( !leftLabel.isEmpty() ) {
216         QLabel* aLeftLabel = new QLabel( this );
217         aLeftLabel->setText( leftLabel );
218         aHBoxL->addWidget( aLeftLabel );
219       }
220
221       _slider = new QSlider( Qt::Horizontal, this );
222       _slider->setRange( 0, toInt( top ));
223       _slider->setValue( toInt( initValue ));
224       aHBoxL->addWidget( _slider );
225
226       if ( !rightLabel.isEmpty() ) {
227         QLabel* aRightLabel = new QLabel( this );
228         aRightLabel->setText( rightLabel );
229         aHBoxL->addWidget( aRightLabel );
230       }
231
232       setLayout( aHBoxL );
233     }
234     double value() const { return _bottom + _slider->value() * _precision; }
235     QSlider * getSlider() const { return _slider; }
236     int toInt( double val ) const { return (int) ceil(( val - _bottom ) / _precision ); }
237   private:
238     double _bottom, _precision;
239     QSlider * _slider;
240   };
241
242   //================================================================================
243   /*!
244    * \brief Retrieve GEOM_Object held by widget
245    */
246   //================================================================================
247
248   inline GEOM::GEOM_Object_var geomFromWdg(const QWidget* wdg)
249   {
250     const StdMeshersGUI_ObjectReferenceParamWdg * objRefWdg =
251       dynamic_cast<const StdMeshersGUI_ObjectReferenceParamWdg*>( wdg );
252     if ( objRefWdg )
253       return objRefWdg->GetObject< GEOM::GEOM_Object >();
254
255     return GEOM::GEOM_Object::_nil();
256   }
257   //================================================================================
258   /*!
259    * \brief Retrieve SMESH_Mesh held by widget
260    */
261   //================================================================================
262
263   inline SMESH::SMESH_Mesh_var meshFromWdg(const QWidget* wdg)
264   {
265     const StdMeshersGUI_ObjectReferenceParamWdg * objRefWdg =
266       dynamic_cast<const StdMeshersGUI_ObjectReferenceParamWdg*>( wdg );
267     if ( objRefWdg )
268       return objRefWdg->GetObject< SMESH::SMESH_Mesh >();
269
270     return SMESH::SMESH_Mesh::_nil();
271   }
272   //================================================================================
273   /*!
274    * \brief Retrieve SMESH_Mesh held by widget
275    */
276   //================================================================================
277
278   inline SMESH::ListOfGroups_var groupsFromWdg(const QWidget* wdg)
279   {
280     SMESH::ListOfGroups_var groups = new SMESH::ListOfGroups;
281     const StdMeshersGUI_ObjectReferenceParamWdg * objRefWdg =
282       dynamic_cast<const StdMeshersGUI_ObjectReferenceParamWdg*>( wdg );
283     if ( objRefWdg )
284     {
285       groups->length( objRefWdg->NbObjects() );
286       for ( unsigned i = 0; i < groups->length(); ++i )
287         groups[i] = objRefWdg->GetObject< SMESH::SMESH_GroupBase >(i);
288     }
289     return groups;
290   }
291   //================================================================================
292   /*!
293    * \brief creates a filter for selection of shapes of given dimension
294     * \param dim - dimension
295     * \param subShapeType - required type of sub-shapes, number of which must be \a nbSubShapes
296     * \param nbSubShapes - number of sub-shapes of given type
297     * \param closed - required closeness flag of a shape
298     * \retval SUIT_SelectionFilter* - created filter
299    */
300   //================================================================================
301
302   SUIT_SelectionFilter* filterForShapeOfDim(const int        dim,
303                                             TopAbs_ShapeEnum subShapeType = TopAbs_SHAPE,
304                                             const int        nbSubShapes = 0,
305                                             bool             closed = false)
306   {
307     TColStd_MapOfInteger shapeTypes;
308     switch ( dim ) {
309     case 0: shapeTypes.Add( TopAbs_VERTEX ); break;
310     case 1:
311       if ( subShapeType == TopAbs_SHAPE ) subShapeType = TopAbs_EDGE;
312       shapeTypes.Add( TopAbs_EDGE );
313       shapeTypes.Add( TopAbs_COMPOUND ); // for a group
314       break;
315     case 2:
316       if ( subShapeType == TopAbs_SHAPE ) subShapeType = TopAbs_FACE;
317       shapeTypes.Add( TopAbs_FACE );
318       shapeTypes.Add( TopAbs_COMPOUND ); // for a group
319       break;
320     case 3:
321       shapeTypes.Add( TopAbs_SHELL );
322       shapeTypes.Add( TopAbs_SOLID );
323       shapeTypes.Add( TopAbs_COMPSOLID );
324       shapeTypes.Add( TopAbs_COMPOUND );
325       break;
326     }
327     return new SMESH_NumberFilter("GEOM", subShapeType, nbSubShapes,
328                                   shapeTypes, GEOM::GEOM_Object::_nil(), closed);
329   }
330
331   //================================================================================
332   /*!
333    * \brief Create a widget for object selection
334     * \param object - initial object
335     * \param filter - selection filter
336     * \retval QWidget* - created widget
337    */
338   //================================================================================
339
340   QWidget* newObjRefParamWdg( SUIT_SelectionFilter* filter,
341                               CORBA::Object_var     object)
342   {
343     StdMeshersGUI_ObjectReferenceParamWdg* w =
344       new StdMeshersGUI_ObjectReferenceParamWdg( filter, 0);
345     w->SetObject( object.in() );
346     return w;
347   }
348   QWidget* newObjRefParamWdg( SUIT_SelectionFilter*    filter,
349                               SMESH::string_array_var& objEntries)
350   {
351     StdMeshersGUI_ObjectReferenceParamWdg* w =
352       new StdMeshersGUI_ObjectReferenceParamWdg( filter, 0, /*multiSel=*/true);
353     //RNV: Firstly, activate selection, then set objects
354     w->activateSelection();
355     w->SetObjects( objEntries );
356     return w;
357   }
358
359   //================================================================================
360   /*!
361    * \brief calls deactivateSelection() for StdMeshersGUI_ObjectReferenceParamWdg
362     * \param widgetList - list of widgets
363    */
364   //================================================================================
365
366   void deactivateObjRefParamWdg( QList<QWidget*>* widgetList )
367   {
368     StdMeshersGUI_ObjectReferenceParamWdg* w = 0;
369     QList<QWidget*>::iterator anIt  = widgetList->begin();
370     QList<QWidget*>::iterator aLast = widgetList->end();
371     for ( ; anIt != aLast; anIt++ ) {
372       if ( (*anIt) && (*anIt)->inherits( "StdMeshersGUI_ObjectReferenceParamWdg" ))
373       {
374         w = (StdMeshersGUI_ObjectReferenceParamWdg* )( *anIt );
375         w->deactivateSelection();
376       }
377     }
378   }
379 }
380
381 //================================================================================
382 /*!
383  * \brief Remove a group, whose name is stored by hypothesis, upon group name modification
384  *  \param [in] oldName - old group name
385  *  \param [in] newName - new group name
386  *  \param [in] type - group type
387  */
388 //================================================================================
389
390 void StdMeshersGUI_StdHypothesisCreator::
391 removeOldGroup(const char* oldName, const char* newName, SMESH::ElementType type) const
392 {
393   if ( !oldName || !oldName[0] )
394     return; // old name undefined
395   if ( newName && strcmp( oldName, newName ) == 0 )
396     return; // same name
397
398   SMESH::SMESH_Hypothesis_var h = hypothesis();
399   SMESH::SObjectList listSOmesh = SMESH::GetMeshesUsingAlgoOrHypothesis( h );
400   for ( size_t i = 0; i < listSOmesh.size(); i++ )
401   {
402     _PTR(SObject) submSO = listSOmesh[i];
403     SMESH::SMESH_Mesh_var       mesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( submSO );
404     SMESH::SMESH_subMesh_var subMesh = SMESH::SObjectToInterface<SMESH::SMESH_subMesh>( submSO );
405     if( !subMesh->_is_nil() )
406       mesh = subMesh->GetFather();
407     if ( mesh->_is_nil() )
408       continue;
409     SMESH::ListOfGroups_var groups = mesh->GetGroups();
410     for ( CORBA::ULong iG = 0; iG < groups->length(); iG++ )
411     {
412       if ( groups[iG]->GetType() != type )
413         continue;
414       CORBA::String_var name = groups[iG]->GetName();
415       if ( strcmp( name.in(), oldName ))
416         continue;
417       mesh->RemoveGroup( groups[iG] );
418     }
419   }
420 }
421
422 //================================================================================
423 /*!
424  * \brief Check parameter values before accept()
425  *  \retval bool - true if OK
426  */
427 //================================================================================
428
429 bool StdMeshersGUI_StdHypothesisCreator::checkParams( QString& msg ) const
430 {
431   if( !SMESHGUI_GenericHypothesisCreator::checkParams( msg ) )
432     return false;
433
434   // check if object reference parameter is set, as it has no default value
435   bool ok = true;
436   if ( hypType().startsWith("ProjectionSource" ))
437   {
438     StdMeshersGUI_ObjectReferenceParamWdg* w =
439       widget< StdMeshersGUI_ObjectReferenceParamWdg >( 0 );
440     ok = ( w->IsObjectSelected() );
441     if ( !ok ) w->SetObject( CORBA::Object::_nil() );
442     int nbAssocVert = ( hypType() == "ProjectionSource1D" ? 1 : 2 );
443     int nbNonEmptyAssoc = 0;
444     for ( int i = 0; ok && i < nbAssocVert*2; i += 2)
445     {
446       QString srcV, tgtV;
447       StdMeshersGUI_ObjectReferenceParamWdg* w1 =
448         widget< StdMeshersGUI_ObjectReferenceParamWdg >( i+2 );
449       StdMeshersGUI_ObjectReferenceParamWdg* w2 =
450         widget< StdMeshersGUI_ObjectReferenceParamWdg >( i+3 );
451       srcV = w1->GetValue();
452       tgtV = w2->GetValue();
453       ok = (( srcV.isEmpty()  && tgtV.isEmpty() ) ||
454             ( !srcV.isEmpty() && !tgtV.isEmpty() /*&& srcV != tgtV*/ ));
455       if ( !ok ) {
456         w1->SetObject( CORBA::Object::_nil() );
457         w2->SetObject( CORBA::Object::_nil() );
458       }
459       nbNonEmptyAssoc += !srcV.isEmpty();
460     }
461     if ( ok && nbNonEmptyAssoc == 1 && nbAssocVert == 2 )
462     {
463       // only one pair of VERTEXes is given for a FACE,
464       // then the FACE must have only one VERTEX
465       GEOM::GEOM_Object_var face = w->GetObject< GEOM::GEOM_Object >();
466
467       GEOM::GEOM_Gen_var geomGen = SMESH::GetGEOMGen( face );
468       _PTR(Study)         aStudy = SMESH::getStudy();
469       GEOM::GEOM_IShapesOperations_wrap shapeOp;
470       if ( !geomGen->_is_nil() && aStudy )
471         shapeOp = geomGen->GetIShapesOperations();
472       if ( !shapeOp->_is_nil() )
473       {
474         GEOM::ListOfLong_var vertices =
475           shapeOp->GetAllSubShapesIDs (face, GEOM::VERTEX, /*isSorted=*/false);
476         ok = ( vertices->length() == 1 );
477       }
478     }
479     // Uninstall filters of StdMeshersGUI_ObjectReferenceParamWdg
480     if ( ok )
481       deactivateObjRefParamWdg( customWidgets() );
482   }
483   else if ( hypType().startsWith("ImportSource" ))
484   {
485     StdMeshersGUI_ObjectReferenceParamWdg* w =
486       widget< StdMeshersGUI_ObjectReferenceParamWdg >( 0 );
487     ok = ( w->IsObjectSelected() );
488   }
489   else if ( hypType() == "LayerDistribution" || hypType() == "LayerDistribution2D" )
490   {
491     StdMeshersGUI_LayerDistributionParamWdg* w = 
492       widget< StdMeshersGUI_LayerDistributionParamWdg >( 0 );
493     ok = ( w && w->IsOk() );
494   }
495
496   return ok;
497 }
498
499 //================================================================================
500 /*!
501  * \brief Store params from GUI controls to a hypothesis
502   * \retval QString - text representation of parameters
503  */
504 //================================================================================
505
506 QString StdMeshersGUI_StdHypothesisCreator::storeParams() const
507 {
508   ListOfStdParams params;
509   bool res = getStdParamFromDlg( params );
510   if( isCreation() )
511   {
512     SMESH::SetName( SMESH::FindSObject( hypothesis() ), params[0].myValue.toString().toUtf8().data() );
513     params.erase( params.begin() );
514   }
515
516   QString valueStr = stdParamValues( params );
517   //QStringList aVariablesList = getVariablesFromDlg();
518
519   if( res && !params.isEmpty() )
520   {
521     if( hypType()=="LocalLength" )
522     {
523       StdMeshers::StdMeshers_LocalLength_var h =
524         StdMeshers::StdMeshers_LocalLength::_narrow( hypothesis() );
525
526       h->SetVarParameter( params[0].text(), "SetLength" );
527       h->SetLength( params[0].myValue.toDouble() );
528       h->SetVarParameter( params[1].text(), "SetPrecision" );
529       h->SetPrecision( params[1].myValue.toDouble() );
530     }
531     else if( hypType()=="MaxLength" )
532     {
533       StdMeshers::StdMeshers_MaxLength_var h =
534         StdMeshers::StdMeshers_MaxLength::_narrow( hypothesis() );
535
536       h->SetVarParameter( params[0].text(), "SetLength" );
537       h->SetLength( params[0].myValue.toDouble() );
538       h->SetUsePreestimatedLength( widget< QCheckBox >( 1 )->isChecked() );
539       if ( !h->HavePreestimatedLength() && !h->_is_equivalent( initParamsHypothesis() )) {
540         StdMeshers::StdMeshers_MaxLength_var hInit =
541           StdMeshers::StdMeshers_MaxLength::_narrow( initParamsHypothesis() );
542         h->SetPreestimatedLength( hInit->GetPreestimatedLength() );
543       }
544     }
545     else if( hypType()=="SegmentLengthAroundVertex" )
546     {
547       StdMeshers::StdMeshers_SegmentLengthAroundVertex_var h =
548         StdMeshers::StdMeshers_SegmentLengthAroundVertex::_narrow( hypothesis() );
549
550       h->SetVarParameter( params[0].text(), "SetLength" );
551       h->SetLength( params[0].myValue.toDouble() );
552     }
553     else if( hypType()=="Arithmetic1D" )
554     {
555       StdMeshers::StdMeshers_Arithmetic1D_var h =
556         StdMeshers::StdMeshers_Arithmetic1D::_narrow( hypothesis() );
557
558       StdMeshersGUI_SubShapeSelectorWdg* w = 
559         widget< StdMeshersGUI_SubShapeSelectorWdg >( 2 );
560
561       h->SetVarParameter( params[0].text(), "SetStartLength" );
562       h->SetStartLength( params[0].myValue.toDouble() );
563       h->SetVarParameter( params[1].text(), "SetEndLength" );
564       h->SetEndLength( params[1].myValue.toDouble() );
565       if (w) {
566         h->SetReversedEdges( w->GetListOfIDs() );
567         h->SetObjectEntry( w->GetMainShapeEntry() );
568       }
569     }
570     else if( hypType()=="GeometricProgression" )
571     {
572       StdMeshers::StdMeshers_Geometric1D_var h =
573         StdMeshers::StdMeshers_Geometric1D::_narrow( hypothesis() );
574
575       StdMeshersGUI_SubShapeSelectorWdg* w = 
576         widget< StdMeshersGUI_SubShapeSelectorWdg >( 2 );
577
578       h->SetVarParameter( params[0].text(), "SetStartLength" );
579       h->SetStartLength( params[0].myValue.toDouble() );
580       h->SetVarParameter( params[1].text(), "SetCommonRatio" );
581       h->SetCommonRatio( params[1].myValue.toDouble() );
582       if (w) {
583         h->SetReversedEdges( w->GetListOfIDs() );
584         h->SetObjectEntry( w->GetMainShapeEntry() );
585       }
586     }
587     else if( hypType()=="FixedPoints1D" )
588     {
589       StdMeshers::StdMeshers_FixedPoints1D_var h =
590         StdMeshers::StdMeshers_FixedPoints1D::_narrow( hypothesis() );
591
592       StdMeshersGUI_FixedPointsParamWdg* w1 = 
593         widget< StdMeshersGUI_FixedPointsParamWdg >( 0 );
594
595       StdMeshersGUI_SubShapeSelectorWdg* w2 = 
596         widget< StdMeshersGUI_SubShapeSelectorWdg >( 1 );
597
598       if (w1) {
599         h->SetPoints( w1->GetListOfPoints() );
600         h->SetNbSegments( w1->GetListOfSegments() );
601       }
602       if (w2) {
603         h->SetReversedEdges( w2->GetListOfIDs() );
604         h->SetObjectEntry( w2->GetMainShapeEntry() );
605       }
606     }
607     else if( hypType()=="MaxElementArea" )
608     {
609       StdMeshers::StdMeshers_MaxElementArea_var h =
610         StdMeshers::StdMeshers_MaxElementArea::_narrow( hypothesis() );
611       h->SetVarParameter( params[0].text(), "SetMaxElementArea" );
612       h->SetMaxElementArea( params[0].myValue.toDouble() );
613     }
614     else if( hypType()=="MaxElementVolume" )
615     {
616       StdMeshers::StdMeshers_MaxElementVolume_var h =
617         StdMeshers::StdMeshers_MaxElementVolume::_narrow( hypothesis() );
618
619       h->SetVarParameter( params[0].text(), "SetMaxElementVolume" );
620       h->SetMaxElementVolume( params[0].myValue.toDouble() );
621     }
622     else if( hypType()=="StartEndLength" )
623     {
624       StdMeshers::StdMeshers_StartEndLength_var h =
625         StdMeshers::StdMeshers_StartEndLength::_narrow( hypothesis() );
626
627       StdMeshersGUI_SubShapeSelectorWdg* w = 
628         widget< StdMeshersGUI_SubShapeSelectorWdg >( 2 );
629
630       h->SetVarParameter( params[0].text(), "SetStartLength" );
631       h->SetStartLength( params[0].myValue.toDouble() );
632       h->SetVarParameter( params[1].text(), "SetEndLength" );
633       h->SetEndLength( params[1].myValue.toDouble() );
634       if (w) {
635         h->SetReversedEdges( w->GetListOfIDs() );
636         h->SetObjectEntry( w->GetMainShapeEntry() );
637       }
638     }
639     else if( hypType()=="Deflection1D" )
640     {
641       StdMeshers::StdMeshers_Deflection1D_var h =
642         StdMeshers::StdMeshers_Deflection1D::_narrow( hypothesis() );
643       h->SetVarParameter( params[0].text(), "SetDeflection" );
644       h->SetDeflection( params[0].myValue.toDouble() );
645     }
646     else if( hypType()=="Adaptive1D" )
647     {
648       StdMeshers::StdMeshers_Adaptive1D_var h =
649         StdMeshers::StdMeshers_Adaptive1D::_narrow( hypothesis() );
650       h->SetVarParameter( params[0].text(), "SetMinSize" );
651       h->SetMinSize( params[0].myValue.toDouble() );
652       h->SetVarParameter( params[0].text(), "SetMaxSize" );
653       h->SetMaxSize( params[1].myValue.toDouble() );
654       h->SetVarParameter( params[0].text(), "SetDeflection" );
655       h->SetDeflection( params[2].myValue.toDouble() );
656     }
657     else if( hypType()=="AutomaticLength" )
658     {
659       StdMeshers::StdMeshers_AutomaticLength_var h =
660         StdMeshers::StdMeshers_AutomaticLength::_narrow( hypothesis() );
661
662       h->SetVarParameter( params[0].text(), "SetFineness" );
663       h->SetFineness( params[0].myValue.toDouble() );
664     }
665     else if( hypType()=="NumberOfLayers" )
666     {
667       StdMeshers::StdMeshers_NumberOfLayers_var h =
668         StdMeshers::StdMeshers_NumberOfLayers::_narrow( hypothesis() );
669
670       h->SetVarParameter( params[0].text(), "SetNumberOfLayers" );
671       h->SetNumberOfLayers( params[0].myValue.toInt() );
672     }
673     else if( hypType()=="LayerDistribution" )
674     {
675       StdMeshers::StdMeshers_LayerDistribution_var h =
676         StdMeshers::StdMeshers_LayerDistribution::_narrow( hypothesis() );
677       StdMeshersGUI_LayerDistributionParamWdg* w = 
678         widget< StdMeshersGUI_LayerDistributionParamWdg >( 0 );
679       
680       h->SetLayerDistribution( w->GetHypothesis() );
681     }
682     else if( hypType()=="NumberOfLayers2D" )
683     {
684       StdMeshers::StdMeshers_NumberOfLayers2D_var h =
685         StdMeshers::StdMeshers_NumberOfLayers2D::_narrow( hypothesis() );
686
687       h->SetVarParameter( params[0].text(), "SetNumberOfLayers" );
688       h->SetNumberOfLayers( params[0].myValue.toInt() );
689     }
690     else if( hypType()=="LayerDistribution2D" )
691     {
692       StdMeshers::StdMeshers_LayerDistribution2D_var h =
693         StdMeshers::StdMeshers_LayerDistribution2D::_narrow( hypothesis() );
694       StdMeshersGUI_LayerDistributionParamWdg* w = 
695         widget< StdMeshersGUI_LayerDistributionParamWdg >( 0 );
696       
697       h->SetLayerDistribution( w->GetHypothesis() );
698     }
699     else if( hypType()=="ProjectionSource1D" )
700     {
701       StdMeshers::StdMeshers_ProjectionSource1D_var h =
702         StdMeshers::StdMeshers_ProjectionSource1D::_narrow( hypothesis() );
703
704       h->SetSourceEdge       ( geomFromWdg ( getWidgetForParam( 0 )));
705       h->SetSourceMesh       ( meshFromWdg ( getWidgetForParam( 1 )));
706       h->SetVertexAssociation( geomFromWdg ( getWidgetForParam( 2 )),
707                                geomFromWdg ( getWidgetForParam( 3 )));
708     }
709     else if( hypType()=="ProjectionSource2D" )
710     {
711       StdMeshers::StdMeshers_ProjectionSource2D_var h =
712         StdMeshers::StdMeshers_ProjectionSource2D::_narrow( hypothesis() );
713
714       h->SetSourceFace       ( geomFromWdg ( getWidgetForParam( 0 )));
715       h->SetSourceMesh       ( meshFromWdg ( getWidgetForParam( 1 )));
716       h->SetVertexAssociation( geomFromWdg ( getWidgetForParam( 2 )), // src1
717                                geomFromWdg ( getWidgetForParam( 4 )), // src2
718                                geomFromWdg ( getWidgetForParam( 3 )), // tgt1
719                                geomFromWdg ( getWidgetForParam( 5 ))); // tgt2
720     }
721     else if( hypType()=="ProjectionSource3D" )
722     {
723       StdMeshers::StdMeshers_ProjectionSource3D_var h =
724         StdMeshers::StdMeshers_ProjectionSource3D::_narrow( hypothesis() );
725
726       h->SetSource3DShape    ( geomFromWdg ( getWidgetForParam( 0 )));
727       h->SetSourceMesh       ( meshFromWdg ( getWidgetForParam( 1 )));
728       h->SetVertexAssociation( geomFromWdg ( getWidgetForParam( 2 )), // src1
729                                geomFromWdg ( getWidgetForParam( 4 )), // src2
730                                geomFromWdg ( getWidgetForParam( 3 )), // tgt1
731                                geomFromWdg ( getWidgetForParam( 5 ))); // tgt2
732     }
733     else if( hypType()=="ImportSource1D" )
734     {
735       StdMeshers::StdMeshers_ImportSource1D_var h =
736         StdMeshers::StdMeshers_ImportSource1D::_narrow( hypothesis() );
737
738       SMESH::ListOfGroups_var groups = groupsFromWdg( getWidgetForParam( 0 ));
739       h->SetSourceEdges( groups.in() );
740       QCheckBox* toCopyMesh   = widget< QCheckBox >( 1 );
741       QCheckBox* toCopyGroups = widget< QCheckBox >( 2 );
742       h->SetCopySourceMesh( toCopyMesh->isChecked(), toCopyGroups->isChecked());
743     }
744     else if( hypType()=="ImportSource2D" )
745     {
746       StdMeshers::StdMeshers_ImportSource2D_var h =
747         StdMeshers::StdMeshers_ImportSource2D::_narrow( hypothesis() );
748
749       SMESH::ListOfGroups_var groups = groupsFromWdg( getWidgetForParam( 0 ));
750       h->SetSourceFaces( groups.in() );
751       QCheckBox* toCopyMesh   = widget< QCheckBox >( 1 );
752       QCheckBox* toCopyGroups = widget< QCheckBox >( 2 );
753       h->SetCopySourceMesh( toCopyMesh->isChecked(), toCopyGroups->isChecked());
754     }
755     else if( hypType()=="ViscousLayers" )
756     {
757       StdMeshers::StdMeshers_ViscousLayers_var h =
758         StdMeshers::StdMeshers_ViscousLayers::_narrow( hypothesis() );
759
760       h->SetVarParameter  ( params[0].text(), "SetTotalThickness" );
761       h->SetTotalThickness( params[0].myValue.toDouble() );
762       h->SetVarParameter  ( params[1].text(), "SetNumberLayers" );
763       h->SetNumberLayers  ( params[1].myValue.toInt() );
764       h->SetVarParameter  ( params[2].text(), "SetStretchFactor" );
765       h->SetStretchFactor ( params[2].myValue.toDouble() );
766       h->SetMethod (( StdMeshers::VLExtrusionMethod ) params[3].myValue.toInt() );
767
768       if ( StdMeshersGUI_SubShapeSelectorWdg* idsWg =
769            widget< StdMeshersGUI_SubShapeSelectorWdg >( 5 ))
770       {
771         h->SetFaces( idsWg->GetListOfIDs(), params[4].myValue.toInt() );
772       }
773
774       if ( StdMeshersGUI_NameCheckableGrpWdg* nameWg =
775            widget< StdMeshersGUI_NameCheckableGrpWdg >( 6 ))
776       {
777         CORBA::String_var oldName = h->GetGroupName();
778         h->SetGroupName( nameWg->getName().toUtf8().data() );
779         CORBA::String_var newName = h->GetGroupName();
780         removeOldGroup( oldName, newName, SMESH::VOLUME );
781       }
782     }
783     else if( hypType()=="ViscousLayers2D" )
784     {
785       StdMeshers::StdMeshers_ViscousLayers2D_var h =
786         StdMeshers::StdMeshers_ViscousLayers2D::_narrow( hypothesis() );
787
788       h->SetVarParameter  ( params[0].text(), "SetTotalThickness" );
789       h->SetTotalThickness( params[0].myValue.toDouble() );
790       h->SetVarParameter  ( params[1].text(), "SetNumberLayers" );
791       h->SetNumberLayers  ( params[1].myValue.toInt() );
792       h->SetVarParameter  ( params[2].text(), "SetStretchFactor" );
793       h->SetStretchFactor ( params[2].myValue.toDouble() );
794
795       if ( StdMeshersGUI_SubShapeSelectorWdg* idsWg =
796            widget< StdMeshersGUI_SubShapeSelectorWdg >( 4 ))
797       {
798         h->SetEdges( idsWg->GetListOfIDs(), params[3].myValue.toInt() );
799       }
800
801       if ( StdMeshersGUI_NameCheckableGrpWdg* nameWg =
802            widget< StdMeshersGUI_NameCheckableGrpWdg >( 5 ))
803       {
804         CORBA::String_var oldName = h->GetGroupName();
805         h->SetGroupName( nameWg->getName().toUtf8().data() );
806         CORBA::String_var newName = h->GetGroupName();
807         removeOldGroup( oldName, newName, SMESH::FACE );
808       }
809     }
810     // else if( hypType()=="QuadrangleParams" )
811     // {
812     //   StdMeshers::StdMeshers_QuadrangleParams_var h =
813     //     StdMeshers::StdMeshers_QuadrangleParams::_narrow( hypothesis() );
814     //   StdMeshersGUI_SubShapeSelectorWdg* w1 =
815     //     widget< StdMeshersGUI_SubShapeSelectorWdg >( 0 );
816     //   StdMeshersGUI_QuadrangleParamWdg* w2 =
817     //     widget< StdMeshersGUI_QuadrangleParamWdg >( 1 );
818     //   if (w1 && w2) {
819     //     if (w1->GetListSize() > 0) {
820     //       h->SetTriaVertex(w1->GetListOfIDs()[0]); // getlist must be called once
821     //       const char * entry = w1->GetMainShapeEntry();
822     //       h->SetObjectEntry(entry);
823     //     }
824     //     h->SetQuadType(StdMeshers::QuadType(w2->GetType()));
825     //   }
826     // }
827   }
828   return valueStr;
829 }
830
831 //================================================================================
832 /*!
833  * \brief Return parameter values as SMESHGUI_GenericHypothesisCreator::StdParam
834  * \param p - list of parameters
835  * \retval bool - success flag
836  *
837  * Is called from SMESHGUI_GenericHypothesisCreator::buildStdFrame().
838  * Parameters will be shown using "standard" controls:
839  *   Int by QtxIntSpinBox
840  *   Double by SMESHGUI_SpinBox
841  *   String by QLineEdit
842  * getCustomWidget() allows to redefine control for a parameter
843  */
844 //================================================================================
845
846 bool StdMeshersGUI_StdHypothesisCreator::stdParams( ListOfStdParams& p ) const
847 {
848   bool res = true;
849   SMESHGUI_GenericHypothesisCreator::StdParam item;
850
851   p.clear();
852   customWidgets()->clear();
853   if( isCreation() )
854   {
855     HypothesisData* data = SMESH::GetHypothesisData( hypType() );
856     item.myName = tr( "SMESH_NAME" );
857     item.myValue = data ? hypName() : QString();
858     p.append( item );
859     customWidgets()->append(0);
860   }
861
862   SMESH::SMESH_Hypothesis_var hyp = initParamsHypothesis();
863   //SMESH::ListOfParameters_var aParameters = hyp->GetLastParameters();
864
865   if( hypType()=="LocalLength" )
866   {
867     StdMeshers::StdMeshers_LocalLength_var h =
868       StdMeshers::StdMeshers_LocalLength::_narrow( hyp );
869
870     item.myName = tr("SMESH_LOCAL_LENGTH_PARAM");
871     if(!initVariableName( hyp, item, "SetLength"))
872       item.myValue = h->GetLength();
873     p.append( item );     
874
875     item.myName = tr("SMESH_LOCAL_LENGTH_PRECISION");
876     if(!initVariableName( hyp, item, "SetPrecision"))
877       item.myValue = h->GetPrecision(); 
878     p.append( item );
879   }
880   else if( hypType()=="MaxLength" )
881   {
882     StdMeshers::StdMeshers_MaxLength_var h =
883       StdMeshers::StdMeshers_MaxLength::_narrow( hyp );
884     // try to set a right preestimated length to edited hypothesis
885     bool noPreestimatedAtEdition = false;
886     if ( !isCreation() ) {
887       StdMeshers::StdMeshers_MaxLength_var initHyp =
888         StdMeshers::StdMeshers_MaxLength::_narrow( initParamsHypothesis(true) );
889       noPreestimatedAtEdition =
890         ( initHyp->_is_nil() || !initHyp->HavePreestimatedLength() );
891       if ( !noPreestimatedAtEdition )
892         h->SetPreestimatedLength( initHyp->GetPreestimatedLength() );
893     }
894
895     item.myName = tr("SMESH_LOCAL_LENGTH_PARAM");
896     if(!initVariableName( hyp, item, "SetLength"))
897       item.myValue = h->GetLength();
898     p.append( item );
899     customWidgets()->append(0);
900
901     item.myName = tr("SMESH_USE_PREESTIMATED_LENGTH");
902     p.append( item );
903     QCheckBox* aQCheckBox = new QCheckBox(dlg());
904     if ( h->HavePreestimatedLength() ) {
905       aQCheckBox->setChecked( h->GetUsePreestimatedLength() );
906       connect( aQCheckBox, SIGNAL(  stateChanged(int) ), this, SLOT( onValueChanged() ) );
907     }
908     else {
909       aQCheckBox->setChecked( false );
910       aQCheckBox->setEnabled( false );
911     }
912     customWidgets()->append( aQCheckBox );
913   }
914   else if( hypType()=="SegmentLengthAroundVertex" )
915   {
916     StdMeshers::StdMeshers_SegmentLengthAroundVertex_var h =
917       StdMeshers::StdMeshers_SegmentLengthAroundVertex::_narrow( hyp );
918
919     item.myName = tr("SMESH_LOCAL_LENGTH_PARAM");
920     if(!initVariableName( hyp, item, "SetLength"))
921       item.myValue = h->GetLength();
922     
923     p.append( item );
924   }
925   else if( hypType()=="Arithmetic1D" )
926   {
927     StdMeshers::StdMeshers_Arithmetic1D_var h =
928       StdMeshers::StdMeshers_Arithmetic1D::_narrow( hyp );
929
930     item.myName = tr( "SMESH_START_LENGTH_PARAM" );
931     if(!initVariableName( hyp, item, "SetStartLength" ))
932       item.myValue = h->GetLength( true );
933     p.append( item );
934
935     customWidgets()->append (0);
936
937     item.myName = tr( "SMESH_END_LENGTH_PARAM" );
938     if(!initVariableName( hyp, item, "SetEndLength" ))
939       item.myValue = h->GetLength( false );
940     p.append( item );
941
942     customWidgets()->append (0);
943
944     item.myName = tr( "SMESH_REVERSED_EDGES" );
945     p.append( item );
946
947     customWidgets()->append ( makeReverseEdgesWdg( h->GetReversedEdges(), h->GetObjectEntry() ));
948   }
949
950   else if( hypType()=="GeometricProgression" )
951   {
952     StdMeshers::StdMeshers_Geometric1D_var h =
953       StdMeshers::StdMeshers_Geometric1D::_narrow( hyp );
954
955     item.myName = tr( "SMESH_START_LENGTH_PARAM" );
956     if(!initVariableName( hyp, item, "SetStartLength" ))
957       item.myValue = h->GetStartLength();
958     p.append( item );
959
960     customWidgets()->append (0);
961
962     item.myName = tr( "SMESH_COMMON_RATIO" );
963     if(!initVariableName( hyp, item, "SetCommonRatio" ))
964       item.myValue = h->GetCommonRatio();
965     p.append( item );
966
967     customWidgets()->append (0);
968
969     item.myName = tr( "SMESH_REVERSED_EDGES" );
970     p.append( item );
971
972     customWidgets()->append ( makeReverseEdgesWdg( h->GetReversedEdges(), h->GetObjectEntry() ));
973   }
974
975   else if( hypType()=="FixedPoints1D" )
976   {
977     StdMeshers::StdMeshers_FixedPoints1D_var h =
978       StdMeshers::StdMeshers_FixedPoints1D::_narrow( hyp );
979
980     item.myName = tr( "SMESH_FIXED_POINTS" );
981     p.append( item );
982
983     StdMeshersGUI_FixedPointsParamWdg* aFixedPointsWidget =
984       new StdMeshersGUI_FixedPointsParamWdg();
985
986     if ( !isCreation() ) {
987       aFixedPointsWidget->SetListOfPoints( h->GetPoints() );
988       aFixedPointsWidget->SetListOfSegments( h->GetNbSegments() );
989     }
990     customWidgets()->append( aFixedPointsWidget );
991
992     item.myName = tr( "SMESH_REVERSED_EDGES" );
993     p.append( item );
994
995     customWidgets()->append ( makeReverseEdgesWdg( h->GetReversedEdges(), h->GetObjectEntry() ));
996   }
997
998
999   else if( hypType()=="MaxElementArea" )
1000   {
1001     StdMeshers::StdMeshers_MaxElementArea_var h =
1002       StdMeshers::StdMeshers_MaxElementArea::_narrow( hyp );
1003
1004     item.myName = tr( "SMESH_MAX_ELEMENT_AREA_PARAM" );
1005     if(!initVariableName( hyp, item, "SetMaxElementArea" ))
1006       item.myValue = h->GetMaxElementArea();
1007     p.append( item );
1008
1009   }
1010   else if( hypType()=="MaxElementVolume" )
1011   {
1012     StdMeshers::StdMeshers_MaxElementVolume_var h =
1013       StdMeshers::StdMeshers_MaxElementVolume::_narrow( hyp );
1014
1015     item.myName = tr( "SMESH_MAX_ELEMENT_VOLUME_PARAM" );
1016     if(!initVariableName( hyp, item, "SetMaxElementVolume" ))
1017       item.myValue = h->GetMaxElementVolume();
1018     p.append( item );
1019   }
1020   else if( hypType()=="StartEndLength" )
1021   {
1022     StdMeshers::StdMeshers_StartEndLength_var h =
1023       StdMeshers::StdMeshers_StartEndLength::_narrow( hyp );
1024
1025     item.myName = tr( "SMESH_START_LENGTH_PARAM" );
1026
1027     if(!initVariableName( hyp, item, "SetStartLength" ))
1028       item.myValue = h->GetLength( true );
1029     p.append( item );
1030     customWidgets()->append(0);
1031
1032     item.myName = tr( "SMESH_END_LENGTH_PARAM" );
1033     if(!initVariableName( hyp, item, "SetEndLength" ))
1034       item.myValue = h->GetLength( false );
1035     p.append( item );
1036     customWidgets()->append(0);
1037
1038     item.myName = tr( "SMESH_REVERSED_EDGES" );
1039     p.append( item );
1040
1041     customWidgets()->append ( makeReverseEdgesWdg( h->GetReversedEdges(), h->GetObjectEntry() ));
1042   }
1043   else if( hypType()=="Deflection1D" )
1044   {
1045     StdMeshers::StdMeshers_Deflection1D_var h =
1046       StdMeshers::StdMeshers_Deflection1D::_narrow( hyp );
1047
1048     item.myName = tr( "SMESH_DEFLECTION1D_PARAM" );
1049     if(!initVariableName( hyp, item, "SetDeflection" ))
1050       item.myValue = h->GetDeflection();
1051     p.append( item );
1052   }
1053   else if( hypType()=="Adaptive1D" )
1054   {
1055     StdMeshers::StdMeshers_Adaptive1D_var h =
1056       StdMeshers::StdMeshers_Adaptive1D::_narrow( hyp );
1057
1058     item.myName = tr( "SMESH_MIN_SIZE" );
1059     if(!initVariableName( hyp, item, "SetMinSize" ))
1060       item.myValue = h->GetMinSize();
1061     p.append( item );
1062
1063     item.myName = tr( "SMESH_MAX_SIZE" );
1064     if(!initVariableName( hyp, item, "SetMaxSize" ))
1065       item.myValue = h->GetMaxSize();
1066     p.append( item );
1067
1068     item.myName = tr( "SMESH_DEFLECTION1D_PARAM" );
1069     if(!initVariableName( hyp, item, "SetDeflection" ))
1070       item.myValue = h->GetDeflection();
1071     p.append( item );
1072   }
1073   else if( hypType()=="AutomaticLength" )
1074   {
1075     StdMeshers::StdMeshers_AutomaticLength_var h =
1076       StdMeshers::StdMeshers_AutomaticLength::_narrow( hyp );
1077
1078     item.myName = tr( "SMESH_FINENESS_PARAM" );
1079     //item.myValue = h->GetFineness();
1080     p.append( item );
1081     SMESHGUI_SpinBox* _autoLengthSpinBox = new SMESHGUI_SpinBox(dlg());
1082     _autoLengthSpinBox->RangeStepAndValidator(0, 1, 0.01, "length_precision");
1083     _autoLengthSpinBox->SetValue(h->GetFineness());
1084     customWidgets()->append( _autoLengthSpinBox);
1085   }
1086   else if( hypType()=="NumberOfLayers" )
1087   {
1088     StdMeshers::StdMeshers_NumberOfLayers_var h =
1089       StdMeshers::StdMeshers_NumberOfLayers::_narrow( hyp );
1090
1091     item.myName = tr( "SMESH_NUMBER_OF_LAYERS" );
1092     if(!initVariableName( hyp, item, "SetNumberOfLayers" ))     
1093       item.myValue = (int) h->GetNumberOfLayers();
1094     p.append( item );
1095   }
1096   else if( hypType()=="LayerDistribution" )
1097   {
1098     StdMeshers::StdMeshers_LayerDistribution_var h =
1099       StdMeshers::StdMeshers_LayerDistribution::_narrow( hyp );
1100     
1101     item.myName = tr( "SMESH_LAYERS_DISTRIBUTION" ); p.append( item );
1102     initVariableName( hyp, item, "SetLayerDistribution" );
1103     customWidgets()->append ( new StdMeshersGUI_LayerDistributionParamWdg
1104                               ( h, h->GetLayerDistribution(), hypName(), dlg() ));
1105   }
1106   else if( hypType()=="NumberOfLayers2D" )
1107   {
1108     StdMeshers::StdMeshers_NumberOfLayers2D_var h =
1109       StdMeshers::StdMeshers_NumberOfLayers2D::_narrow( hyp );
1110     
1111     item.myName = tr( "SMESH_NUMBER_OF_LAYERS" );
1112     if(!initVariableName( hyp, item, "SetNumberOfLayers" ))     
1113       item.myValue = (int) h->GetNumberOfLayers();
1114     p.append( item );
1115   }
1116   else if( hypType()=="LayerDistribution2D" )
1117   {
1118     StdMeshers::StdMeshers_LayerDistribution2D_var h =
1119       StdMeshers::StdMeshers_LayerDistribution2D::_narrow( hyp );
1120
1121     item.myName = tr( "SMESH_LAYERS_DISTRIBUTION" ); p.append( item );
1122     initVariableName( hyp, item, "SetLayerDistribution" );
1123     customWidgets()->append ( new StdMeshersGUI_LayerDistributionParamWdg
1124                               ( h, h->GetLayerDistribution(), hypName(), dlg() ));
1125   }
1126   else if( hypType()=="ProjectionSource1D" )
1127   {
1128     StdMeshers::StdMeshers_ProjectionSource1D_var h =
1129       StdMeshers::StdMeshers_ProjectionSource1D::_narrow( hyp );
1130
1131     item.myName = tr( "SMESH_SOURCE_EDGE" ); p.append( item );
1132     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 1 ),
1133                                                h->GetSourceEdge()));
1134     item.myName = tr( "SMESH_SOURCE_MESH" ); p.append( item );
1135     customWidgets()->append( newObjRefParamWdg( new SMESH_TypeFilter( SMESH::MESH ),
1136                                                h->GetSourceMesh()));
1137     item.myName = tr( "SMESH_SOURCE_VERTEX" ); p.append( item );
1138     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1139                                                h->GetSourceVertex()));
1140     item.myName = tr( "SMESH_TARGET_VERTEX" ); p.append( item );
1141     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1142                                                h->GetTargetVertex()));
1143   }
1144   else if( hypType()=="ProjectionSource2D" )
1145   {
1146     StdMeshers::StdMeshers_ProjectionSource2D_var h =
1147       StdMeshers::StdMeshers_ProjectionSource2D::_narrow( hyp );
1148
1149     item.myName = tr( "SMESH_SOURCE_FACE" ); p.append( item );
1150     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 2 ),
1151                                                h->GetSourceFace()));
1152     item.myName = tr( "SMESH_SOURCE_MESH" ); p.append( item );
1153     customWidgets()->append( newObjRefParamWdg( new SMESH_TypeFilter( SMESH::MESH ),
1154                                                h->GetSourceMesh()));
1155     item.myName = tr( "SMESH_SOURCE_VERTEX1" ); p.append( item );
1156     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1157                                                h->GetSourceVertex( 1 )));
1158     item.myName = tr( "SMESH_TARGET_VERTEX1" ); p.append( item );
1159     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1160                                                h->GetTargetVertex( 1 )));
1161     item.myName = tr( "SMESH_SOURCE_VERTEX2" ); p.append( item );
1162     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1163                                                h->GetSourceVertex( 2 )));
1164     item.myName = tr( "SMESH_TARGET_VERTEX2" ); p.append( item );
1165     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1166                                                h->GetTargetVertex( 2 )));
1167   }
1168   else if( hypType()=="ProjectionSource3D" )
1169   {
1170     StdMeshers::StdMeshers_ProjectionSource3D_var h =
1171       StdMeshers::StdMeshers_ProjectionSource3D::_narrow( hyp );
1172
1173     item.myName = tr( "SMESH_SOURCE_3DSHAPE" ); p.append( item );
1174     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 3, TopAbs_FACE, 6, true ),
1175                                                h->GetSource3DShape()));
1176     item.myName = tr( "SMESH_SOURCE_MESH" ); p.append( item );
1177     customWidgets()->append( newObjRefParamWdg( new SMESH_TypeFilter( SMESH::MESH ),
1178                                                h->GetSourceMesh()));
1179     item.myName = tr( "SMESH_SOURCE_VERTEX1" ); p.append( item );
1180     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1181                                                h->GetSourceVertex( 1 )));
1182     item.myName = tr( "SMESH_TARGET_VERTEX1" ); p.append( item );
1183     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1184                                                h->GetTargetVertex( 1 )));
1185     item.myName = tr( "SMESH_SOURCE_VERTEX2" ); p.append( item );
1186     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1187                                                h->GetSourceVertex( 2 )));
1188     item.myName = tr( "SMESH_TARGET_VERTEX2" ); p.append( item );
1189     customWidgets()->append( newObjRefParamWdg( filterForShapeOfDim( 0 ),
1190                                                h->GetTargetVertex( 2 )));
1191   }
1192   else if( hypType()=="ImportSource1D" )
1193   {
1194     StdMeshers::StdMeshers_ImportSource1D_var h =
1195       StdMeshers::StdMeshers_ImportSource1D::_narrow( hyp );
1196
1197     SMESH::string_array_var groupEntries = h->GetSourceEdges();
1198     CORBA::Boolean toCopyMesh, toCopyGroups;
1199     h->GetCopySourceMesh(toCopyMesh, toCopyGroups);
1200
1201     item.myName = tr( "SMESH_SOURCE_EDGES" ); p.append( item );
1202     customWidgets()->append( newObjRefParamWdg( new SMESH_TypeFilter( SMESH::GROUP_EDGE ), 
1203                                                 groupEntries));
1204
1205     item.myName = tr( "SMESH_COPY_MESH" ); p.append( item );
1206     QCheckBox* aQCheckBox = new QCheckBox(dlg());
1207     aQCheckBox->setChecked( toCopyMesh );
1208     connect( aQCheckBox, SIGNAL(  stateChanged(int) ), this, SLOT( onValueChanged() ));
1209     customWidgets()->append( aQCheckBox );
1210
1211     item.myName = tr( "SMESH_TO_COPY_GROUPS" ); p.append( item );
1212     aQCheckBox = new QCheckBox(dlg());
1213     aQCheckBox->setChecked( toCopyGroups );
1214     aQCheckBox->setEnabled( toCopyMesh );
1215     customWidgets()->append( aQCheckBox );
1216   }
1217   else if( hypType()=="ImportSource2D" )
1218   {
1219     StdMeshers::StdMeshers_ImportSource2D_var h =
1220       StdMeshers::StdMeshers_ImportSource2D::_narrow( hyp );
1221
1222     SMESH::string_array_var groupEntries = h->GetSourceFaces();
1223     CORBA::Boolean toCopyMesh, toCopyGroups;
1224     h->GetCopySourceMesh(toCopyMesh, toCopyGroups);
1225
1226     item.myName = tr( "SMESH_SOURCE_FACES" ); p.append( item );
1227     customWidgets()->append( newObjRefParamWdg( new SMESH_TypeFilter( SMESH::GROUP_FACE ), 
1228                                                 groupEntries));
1229
1230     item.myName = tr( "SMESH_COPY_MESH" ); p.append( item );
1231     QCheckBox* aQCheckBox = new QCheckBox(dlg());
1232     aQCheckBox->setChecked( toCopyMesh );
1233     connect( aQCheckBox, SIGNAL(  stateChanged(int) ), this, SLOT( onValueChanged() ));
1234     customWidgets()->append( aQCheckBox );
1235
1236     item.myName = tr( "SMESH_COPY_GROUPS" ); p.append( item );
1237     aQCheckBox = new QCheckBox(dlg());
1238     aQCheckBox->setChecked( toCopyGroups );
1239     aQCheckBox->setEnabled( toCopyMesh );
1240     customWidgets()->append( aQCheckBox );
1241   }
1242   else if( hypType()=="ViscousLayers" )
1243   {
1244     StdMeshers::StdMeshers_ViscousLayers_var h =
1245       StdMeshers::StdMeshers_ViscousLayers::_narrow( hyp );
1246
1247     item.myName = tr( "SMESH_TOTAL_THICKNESS" );
1248     if(!initVariableName( hyp, item, "SetTotalThickness" ))
1249       item.myValue = h->GetTotalThickness();
1250     p.append( item );
1251     customWidgets()->append (0);
1252
1253     item.myName = tr( "SMESH_NUMBER_OF_LAYERS" );
1254     if(!initVariableName( hyp, item, "SetNumberLayers" ))
1255       item.myValue = h->GetNumberLayers();
1256     p.append( item );
1257     customWidgets()->append (0);
1258
1259     item.myName = tr( "SMESH_STRETCH_FACTOR" );
1260     if(!initVariableName( hyp, item, "SetStretchFactor" ))
1261       item.myValue = h->GetStretchFactor();
1262     p.append( item );
1263     customWidgets()->append (0);
1264
1265     item.myName = tr( "EXTRUSION_METHOD" );
1266     p.append( item );
1267     StdMeshersGUI_RadioButtonsGrpWdg* methodWdg = new StdMeshersGUI_RadioButtonsGrpWdg("");
1268     methodWdg->setButtonLabels ( QStringList()
1269                                  << tr("EXTMETH_SURF_OFFSET_SMOOTH")
1270                                  << tr("EXTMETH_FACE_OFFSET")
1271                                  << tr("EXTMETH_NODE_OFFSET"),
1272                                  QStringList()
1273                                  << tr("ICON_EXTMETH_SURF_OFFSET_SMOOTH")
1274                                  << tr("ICON_EXTMETH_FACE_OFFSET")
1275                                  << tr("ICON_EXTMETH_NODE_OFFSET"));
1276     methodWdg->setChecked( (int) h->GetMethod() );
1277     customWidgets()->append( methodWdg );
1278
1279     QString aMainEntry = SMESHGUI_GenericHypothesisCreator::getMainShapeEntry();
1280     QString aSubEntry  = SMESHGUI_GenericHypothesisCreator::getShapeEntry();
1281     if ( !aMainEntry.isEmpty() )
1282     {
1283       item.myName = tr( "TO_IGNORE_FACES_OR_NOT" );
1284       p.append( item );
1285
1286       StdMeshersGUI_RadioButtonsGrpWdg* ignoreWdg = new StdMeshersGUI_RadioButtonsGrpWdg("");
1287       ignoreWdg->setButtonLabels ( QStringList()
1288                                    << tr("NOT_TO_IGNORE_FACES")
1289                                    << tr("TO_IGNORE_FACES") );
1290       ignoreWdg->setChecked( h->GetIsToIgnoreFaces() );
1291       connect(ignoreWdg->getButtonGroup(),SIGNAL(buttonClicked(int)),this,SLOT(onValueChanged()));
1292       customWidgets()->append( ignoreWdg );
1293
1294       item.myName =
1295         tr( h->GetIsToIgnoreFaces() ? "SMESH_FACES_WO_LAYERS" : "SMESH_FACES_WITH_LAYERS" );
1296       p.append( item );
1297
1298       StdMeshersGUI_SubShapeSelectorWdg* idsWg =
1299         new StdMeshersGUI_SubShapeSelectorWdg(0,TopAbs_FACE);
1300
1301       idsWg->SetGeomShapeEntry( aSubEntry, aMainEntry );
1302       if ( idsWg->SetListOfIDs( h->GetFaces() ))
1303       {
1304         idsWg->ShowPreview( true );
1305       }
1306       else
1307       {
1308         SUIT_MessageBox::warning( dlg(),tr( "SMESH_WRN_WARNING" ),tr( "BAD_FACES_WARNING" ));
1309         idsWg->setEnabled( false );
1310       }
1311       customWidgets()->append ( idsWg );
1312     }
1313
1314     item.setNoName();
1315     p.append( item );
1316     StdMeshersGUI_NameCheckableGrpWdg* nameWdg =
1317       new StdMeshersGUI_NameCheckableGrpWdg( tr( "CREATE_GROUPS_FROM_LAYERS" ),
1318                                              tr( "GROUP_NAME" ));
1319     nameWdg->setName( h->GetGroupName() );
1320     if ( nameWdg->getName().isEmpty() )
1321     {
1322       nameWdg->setDefaultName( type() );
1323       nameWdg->setChecked( false );
1324     }
1325     customWidgets()->append ( nameWdg );
1326   }
1327   else if( hypType()=="ViscousLayers2D" )
1328   {
1329     StdMeshers::StdMeshers_ViscousLayers2D_var h =
1330       StdMeshers::StdMeshers_ViscousLayers2D::_narrow( hyp );
1331
1332     item.myName = tr( "SMESH_TOTAL_THICKNESS" );
1333     if(!initVariableName( hyp, item, "SetTotalThickness" ))
1334       item.myValue = h->GetTotalThickness();
1335     p.append( item );
1336     customWidgets()->append (0);
1337
1338     item.myName = tr( "SMESH_NUMBER_OF_LAYERS" );
1339     if(!initVariableName( hyp, item, "SetNumberLayers" ))
1340       item.myValue = h->GetNumberLayers();
1341     p.append( item );
1342     customWidgets()->append (0);
1343
1344     item.myName = tr( "SMESH_STRETCH_FACTOR" );
1345     if(!initVariableName( hyp, item, "SetStretchFactor" ))
1346       item.myValue = h->GetStretchFactor();
1347     p.append( item );
1348     customWidgets()->append (0);
1349
1350     QString aMainEntry = SMESHGUI_GenericHypothesisCreator::getMainShapeEntry();
1351     QString aSubEntry  = SMESHGUI_GenericHypothesisCreator::getShapeEntry();
1352     if ( !aMainEntry.isEmpty() )
1353     {
1354       item.myName = tr("TO_IGNORE_EDGES_OR_NOT");
1355       p.append( item );
1356
1357       StdMeshersGUI_RadioButtonsGrpWdg* ignoreWdg = new StdMeshersGUI_RadioButtonsGrpWdg("");
1358       ignoreWdg->setButtonLabels ( QStringList()
1359                                    << tr("NOT_TO_IGNORE_EDGES")
1360                                    << tr("TO_IGNORE_EDGES") );
1361       ignoreWdg->setChecked( h->GetIsToIgnoreEdges() );
1362       connect(ignoreWdg->getButtonGroup(),SIGNAL(buttonClicked(int)),this,SLOT(onValueChanged()));
1363       customWidgets()->append( ignoreWdg );
1364
1365       item.myName =
1366         tr( h->GetIsToIgnoreEdges() ? "SMESH_EDGES_WO_LAYERS" : "SMESH_EDGES_WITH_LAYERS" );
1367       p.append( item );
1368
1369       StdMeshersGUI_SubShapeSelectorWdg* idsWg =
1370         new StdMeshersGUI_SubShapeSelectorWdg(0,TopAbs_EDGE);
1371
1372       idsWg->SetGeomShapeEntry( aSubEntry, aMainEntry );
1373       if ( idsWg->SetListOfIDs( h->GetEdges() ))
1374       {
1375         idsWg->ShowPreview( true );
1376       }
1377       else
1378       {
1379         SUIT_MessageBox::warning( dlg(),tr( "SMESH_WRN_WARNING" ),tr( "BAD_EDGES_WARNING" ));
1380         idsWg->setEnabled( false );
1381       }
1382       customWidgets()->append ( idsWg );
1383     }
1384
1385     item.setNoName();
1386     p.append( item );
1387     StdMeshersGUI_NameCheckableGrpWdg* nameWdg =
1388       new StdMeshersGUI_NameCheckableGrpWdg( tr( "CREATE_GROUPS_FROM_LAYERS" ),
1389                                              tr( "GROUP_NAME" ));
1390     nameWdg->setName( h->GetGroupName() );
1391     if ( nameWdg->getName().isEmpty() )
1392     {
1393       nameWdg->setDefaultName( type() );
1394       nameWdg->setChecked( false );
1395     }
1396     customWidgets()->append ( nameWdg );
1397   }
1398   else
1399     res = false;
1400   return res;
1401 }
1402
1403 //================================================================================
1404 /*!
1405  * \brief tune "standard" control
1406  *  \param w - control widget
1407  *  \param int - parameter index
1408  */
1409 //================================================================================
1410
1411 void StdMeshersGUI_StdHypothesisCreator::attuneStdWidget (QWidget* w, const int) const
1412 {
1413   SMESHGUI_SpinBox* sb = w->inherits( "SMESHGUI_SpinBox" ) ? ( SMESHGUI_SpinBox* )w : 0;
1414   if ( sb )
1415   {
1416     if( hypType()=="LocalLength" )
1417     {
1418       if (sb->objectName() == tr("SMESH_LOCAL_LENGTH_PARAM"))
1419         sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
1420       else if (sb->objectName() == tr("SMESH_LOCAL_LENGTH_PRECISION"))
1421         sb->RangeStepAndValidator( 0.0, 1.0, 0.05, "len_tol_precision" );
1422     }
1423     else if( hypType()=="Arithmetic1D" )
1424     {
1425       sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "parametric_precision" );
1426     }
1427     else if( hypType()=="GeometricProgression" )
1428     {
1429       if (sb->objectName() == tr("SMESH_START_LENGTH_PARAM"))
1430         sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
1431       else if (sb->objectName() == tr("SMESH_COMMON_RATIO"))
1432         sb->RangeStepAndValidator( -VALUE_MAX, VALUE_MAX, 0.5, "len_tol_precision" );
1433     }
1434     else if( hypType()=="MaxLength" )
1435     {
1436       sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
1437       sb->setEnabled( !widget< QCheckBox >( 1 )->isChecked() );
1438       sb->setMinimumWidth( 150 );
1439     }
1440     else if( hypType()=="MaxElementArea" )
1441     {
1442       sb->RangeStepAndValidator( VALUE_SMALL_2, VALUE_MAX_2, 1.0, "area_precision" );
1443     }
1444     else if( hypType()=="MaxElementVolume" )
1445     {
1446       sb->RangeStepAndValidator( VALUE_SMALL_3, VALUE_MAX_3, 1.0, "vol_precision" );
1447     }
1448     else if( hypType()=="StartEndLength" )
1449     {
1450       sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
1451     }
1452     else if( hypType()=="Deflection1D" )
1453     {
1454       sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "parametric_precision" );
1455     }
1456     else if( hypType()=="Adaptive1D" )
1457     {
1458       sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
1459     }
1460     else if( hypType().startsWith( "ViscousLayers" ))
1461     {
1462       if (sb->objectName() == tr("SMESH_STRETCH_FACTOR"))
1463         sb->RangeStepAndValidator( 1.0, VALUE_MAX, 0.1, "parametric_precision" );
1464       else
1465         sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
1466     }
1467     else // default validator for possible ancestors
1468     {
1469       sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
1470     }
1471   }
1472   else if ( SalomeApp_IntSpinBox* sb = qobject_cast< SalomeApp_IntSpinBox* >( w ))
1473   {
1474     if ( hypType().startsWith( "NumberOfLayers" ) ||
1475          hypType().startsWith( "ViscousLayers" ))
1476     {
1477       sb->setMinimum( 1 );
1478     }
1479   }
1480 }
1481
1482 //================================================================================
1483 /*!
1484  * \brief Return dlg title
1485   * \retval QString - title string
1486  */
1487 //================================================================================
1488
1489 QString StdMeshersGUI_StdHypothesisCreator::caption() const
1490 {
1491   return tr( QString( "SMESH_%1_TITLE" ).arg( hypTypeName( hypType() ) ).toLatin1().data() );
1492 }
1493
1494 //================================================================================
1495 /*!
1496  * \brief return pixmap for dlg icon
1497   * \retval QPixmap - 
1498  */
1499 //================================================================================
1500
1501 QPixmap StdMeshersGUI_StdHypothesisCreator::icon() const
1502 {
1503   QString hypIconName = tr( QString( "ICON_DLG_%1" ).arg( hypTypeName( hypType() ) ).toLatin1().data() );
1504   return SMESHGUI::resourceMgr()->loadPixmap( "SMESH", hypIconName );
1505 }
1506
1507 //================================================================================
1508 /*!
1509  * \brief Return hypothesis type name to show in dlg
1510   * \retval QString - 
1511  */
1512 //================================================================================
1513
1514 QString StdMeshersGUI_StdHypothesisCreator::type() const
1515 {
1516   return tr( QString( "SMESH_%1_HYPOTHESIS" ).arg( hypTypeName( hypType() ) ).toLatin1().data() );
1517 }
1518
1519 //================================================================================
1520 /*!
1521  * \brief String to insert in "SMESH_%1_HYPOTHESIS" to get hypothesis type name
1522  * from message resource file
1523   * \param t - hypothesis type
1524   * \retval QString - result string
1525  */
1526 //================================================================================
1527
1528 QString StdMeshersGUI_StdHypothesisCreator::hypTypeName( const QString& t ) const
1529 {
1530   static QMap<QString,QString>  types;
1531   if( types.isEmpty() )
1532   {
1533     types.insert( "LocalLength", "LOCAL_LENGTH" );
1534     types.insert( "NumberOfSegments", "NB_SEGMENTS" );
1535     types.insert( "MaxElementArea", "MAX_ELEMENT_AREA" );
1536     types.insert( "MaxElementVolume", "MAX_ELEMENT_VOLUME" );
1537     types.insert( "StartEndLength", "START_END_LENGTH" );
1538     types.insert( "Deflection1D", "DEFLECTION1D" );
1539     types.insert( "Adaptive1D", "ADAPTIVE1D" );
1540     types.insert( "Arithmetic1D", "ARITHMETIC_1D" );
1541     types.insert( "GeometricProgression", "GEOMETRIC_1D" );
1542     types.insert( "FixedPoints1D", "FIXED_POINTS_1D" );
1543     types.insert( "AutomaticLength", "AUTOMATIC_LENGTH" );
1544     types.insert( "ProjectionSource1D", "PROJECTION_SOURCE_1D" );
1545     types.insert( "ProjectionSource2D", "PROJECTION_SOURCE_2D" );
1546     types.insert( "ProjectionSource3D", "PROJECTION_SOURCE_3D" );
1547     types.insert( "ImportSource1D", "IMPORT_SOURCE_1D" );
1548     types.insert( "ImportSource2D", "IMPORT_SOURCE_2D" );
1549     types.insert( "NumberOfLayers", "NUMBER_OF_LAYERS" );
1550     types.insert( "LayerDistribution", "LAYER_DISTRIBUTION" );
1551     types.insert( "NumberOfLayers2D", "NUMBER_OF_LAYERS_2D" );
1552     types.insert( "LayerDistribution2D", "LAYER_DISTRIBUTION" );
1553     types.insert( "SegmentLengthAroundVertex", "SEGMENT_LENGTH_AROUND_VERTEX" );
1554     types.insert( "MaxLength", "MAX_LENGTH" );
1555     types.insert( "ViscousLayers", "VISCOUS_LAYERS" );
1556     types.insert( "ViscousLayers2D", "VISCOUS_LAYERS" );
1557     types.insert( "QuadrangleParams", "QUADRANGLE_PARAMS" );
1558     types.insert( "CartesianParameters3D", "CARTESIAN_PARAMS" );
1559   }
1560
1561   QString res;
1562   if( types.contains( t ) )
1563     res = types[ t ];
1564
1565   return res;
1566 }
1567
1568
1569 //=======================================================================
1570 //function : getCustomWidget
1571 //purpose  : is called from buildStdFrame()
1572 //=======================================================================
1573
1574 QWidget* StdMeshersGUI_StdHypothesisCreator::getCustomWidget( const StdParam & /*param*/,
1575                                                               QWidget*         parent,
1576                                                               const int        index) const
1577 {
1578   QWidget* w = 0;
1579   if ( index < customWidgets()->count() ) {
1580     w = customWidgets()->at( index );
1581     if ( w ) {
1582       w->setParent( parent );
1583       w->move( QPoint( 0, 0 ) );
1584     }
1585   }
1586   return w;
1587 }
1588
1589 //================================================================================
1590 /*!
1591  * \brief Set param value taken from a custom widget
1592   * \param param - SMESHGUI_GenericHypothesisCreator::StdParam structure
1593   * \param widget - widget presenting param
1594   * \retval bool - success flag
1595  * 
1596  * this method is called from getStdParamFromDlg()
1597  */
1598 //================================================================================
1599
1600 bool StdMeshersGUI_StdHypothesisCreator::getParamFromCustomWidget( StdParam & param,
1601                                                                    QWidget*   widget) const
1602 {
1603   if ( hypType()=="AutomaticLength" ) {
1604     SMESHGUI_SpinBox* w = dynamic_cast<SMESHGUI_SpinBox*>( widget );
1605     if ( w ) {
1606       param.myValue = w->GetValue();
1607       return true;
1608     }
1609   }
1610   if ( hypType() == "MaxLength" ) {
1611     param.myValue = "";
1612     return true;
1613   }
1614   if ( widget->inherits( "StdMeshersGUI_ObjectReferenceParamWdg" ))
1615   {
1616     // show only 1st reference value
1617     if ( true /*widget == getWidgetForParam( 0 )*/) {
1618       const StdMeshersGUI_ObjectReferenceParamWdg * w =
1619         static_cast<const StdMeshersGUI_ObjectReferenceParamWdg*>( widget );
1620       param.myValue = w->GetValue();
1621     }
1622     return true;
1623   }
1624   if ( widget->inherits( "StdMeshersGUI_LayerDistributionParamWdg" ))
1625   {
1626     const StdMeshersGUI_LayerDistributionParamWdg * w =
1627       static_cast<const StdMeshersGUI_LayerDistributionParamWdg*>( widget );
1628     param.myValue = w->GetValue();
1629     return true;
1630   }
1631   if ( widget->inherits( "StdMeshersGUI_SubShapeSelectorWdg" ))
1632   {
1633     const StdMeshersGUI_SubShapeSelectorWdg * w =
1634       static_cast<const StdMeshersGUI_SubShapeSelectorWdg*>( widget );
1635     param.myValue = w->GetValue();
1636     return true;
1637   }
1638   // if ( widget->inherits( "StdMeshersGUI_QuadrangleParamWdg" ))
1639   // {
1640   //   param.myValue = "QuadType";
1641   //   return true;
1642   // }
1643   if ( widget->inherits( "StdMeshersGUI_FixedPointsParamWdg" ))
1644   {
1645     const StdMeshersGUI_FixedPointsParamWdg * w =
1646       static_cast<const StdMeshersGUI_FixedPointsParamWdg*>( widget );
1647     param.myValue = w->GetValue();
1648     return true;
1649   }
1650   if ( widget->inherits( "QCheckBox" ))
1651   {
1652     //const QCheckBox * w = static_cast<const QCheckBox*>( widget );
1653     //param.myValue = w->isChecked();
1654     return true;
1655   }
1656   if ( widget->inherits( "StdMeshersGUI_RadioButtonsGrpWdg" ))
1657   {
1658     const StdMeshersGUI_RadioButtonsGrpWdg * w =
1659       static_cast<const StdMeshersGUI_RadioButtonsGrpWdg*>( widget );
1660     param.myValue = w->checkedId();
1661     return true;
1662   }
1663   if ( widget->inherits( "StdMeshersGUI_NameCheckableGrpWdg" ))
1664   {
1665     return true;
1666   }
1667   return false;
1668 }
1669
1670 //================================================================================
1671 /*!
1672  * \brief called when operation cancelled
1673  */
1674 //================================================================================
1675
1676 void StdMeshersGUI_StdHypothesisCreator::onReject()
1677 {
1678   if ( hypType().startsWith("ProjectionSource" ) ||
1679        hypType().startsWith("ImportSource" ))
1680   {
1681     // Uninstall filters of StdMeshersGUI_ObjectReferenceParamWdg
1682     deactivateObjRefParamWdg( customWidgets() );
1683   }
1684 }
1685
1686 //================================================================================
1687 /*!
1688  * \brief Update widgets dependent on paramWidget
1689  */
1690 //================================================================================
1691
1692 void StdMeshersGUI_StdHypothesisCreator::valueChanged( QWidget* paramWidget)
1693 {
1694   if ( hypType() == "MaxLength" && paramWidget == getWidgetForParam(1) )
1695   {
1696     getWidgetForParam(0)->setEnabled( !widget< QCheckBox >( 1 )->isChecked() );
1697     if ( !getWidgetForParam(0)->isEnabled() ) {
1698       StdMeshers::StdMeshers_MaxLength_var h =
1699         StdMeshers::StdMeshers_MaxLength::_narrow( initParamsHypothesis() );
1700       widget< QtxDoubleSpinBox >( 0 )->setValue( h->GetPreestimatedLength() );
1701     }
1702   }
1703   else if ( hypType().startsWith("ImportSource") && paramWidget == getWidgetForParam(1) )
1704   {
1705     QCheckBox* toCopyMesh   = (QCheckBox*) paramWidget;
1706     QCheckBox* toCopyGroups = widget< QCheckBox >( 2 );
1707     if ( !toCopyMesh->isChecked() )
1708     {
1709       toCopyGroups->setChecked( false );
1710       toCopyGroups->setEnabled( false );
1711     }
1712     else
1713     {
1714       toCopyGroups->setEnabled( true );
1715     }
1716   }
1717   else if ( hypType().startsWith( "ViscousLayers" ) && paramWidget->inherits("QButtonGroup"))
1718   {
1719     int widgetNumber = hypType() == "ViscousLayers2D" ? 3 : 4;
1720     if ( QLabel* label = getLabel( widgetNumber + 1 ) )
1721     {
1722       bool toIgnore = widget< StdMeshersGUI_RadioButtonsGrpWdg >( widgetNumber )->checkedId();
1723       if ( hypType() == "ViscousLayers2D" )
1724         label->setText( tr( toIgnore ? "SMESH_EDGES_WO_LAYERS" : "SMESH_EDGES_WITH_LAYERS" ));
1725       else
1726         label->setText( tr( toIgnore ? "SMESH_FACES_WO_LAYERS" : "SMESH_FACES_WITH_LAYERS" ));
1727     }
1728   }
1729 }
1730
1731 //================================================================================
1732 /*!
1733  *
1734  */
1735 //================================================================================
1736
1737 bool StdMeshersGUI_StdHypothesisCreator::initVariableName(SMESH::SMESH_Hypothesis_var /*theHyp*/, 
1738                                                           StdParam &                  theParams, 
1739                                                           const char*                 theMethod) const
1740 {
1741   QString aVaribaleName = getVariableName( theMethod );
1742   theParams.isVariable = !aVaribaleName.isEmpty();
1743   if (theParams.isVariable)
1744     theParams.myValue = aVaribaleName;
1745
1746   return theParams.isVariable;
1747 }
1748
1749 //================================================================================
1750 /*!
1751  * \brief Creates two widgets used to define reversed edges for some 1D hypotheses
1752  *  \param [in] edgeIDs - ids of reversed edges to set to the widgets
1753  *  \param [in] shapeEntry - entry of a sub-shape of a sub-mesh if any
1754  *  \return QWidget* - new StdMeshersGUI_SubShapeSelectorWdg; 
1755  *          new StdMeshersGUI_PropagationHelperWdg is stored in \a myHelperWidget field.
1756  */
1757 //================================================================================
1758
1759 QWidget*
1760 StdMeshersGUI_StdHypothesisCreator::makeReverseEdgesWdg( SMESH::long_array_var edgeIDs,
1761                                                          CORBA::String_var     shapeEntry) const
1762 {
1763   QString aGeomEntry = SMESHGUI_GenericHypothesisCreator::getShapeEntry();
1764   QString aMainEntry = SMESHGUI_GenericHypothesisCreator::getMainShapeEntry();
1765   if ( aGeomEntry.isEmpty() && shapeEntry.in() )
1766     aGeomEntry = shapeEntry.in();
1767
1768   StdMeshersGUI_SubShapeSelectorWdg* wdg = new StdMeshersGUI_SubShapeSelectorWdg();
1769   wdg->SetGeomShapeEntry( aGeomEntry, aMainEntry );
1770   wdg->SetListOfIDs( edgeIDs );
1771   wdg->ShowPreview( true );
1772
1773   if ( !aGeomEntry.isEmpty() || !aMainEntry.isEmpty() )
1774     const_cast<StdMeshersGUI_StdHypothesisCreator*>( this )->
1775       myHelperWidget = new StdMeshersGUI_PropagationHelperWdg( wdg );
1776
1777   return wdg;
1778 }