]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESHGUI/SMESHGUI_Hypotheses.cxx
Salome HOME
bos #29143 [CEA] Compute takes too much time in polyhedron per solid use case
[modules/smesh.git] / src / SMESHGUI / SMESHGUI_Hypotheses.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   : SMESHGUI_Hypotheses.cxx
23 //  Author : Julia DOROVSKIKH, Open CASCADE S.A.S.
24 //  SMESH includes
25
26 #include "SMESHGUI_Hypotheses.h"
27
28 #include "SMESHGUI.h"
29 #include "SMESHGUI_HypothesesUtils.h"
30 #include "SMESHGUI_SpinBox.h"
31 #include "SMESHGUI_Utils.h"
32 #include "SMESHGUI_VTKUtils.h"
33 #include "SMESH_Actor.h"
34 #include "SMESH_TypeDefs.hxx"
35
36 // SALOME KERNEL includes
37 #include <SALOMEDSClient_Study.hxx>
38 #include <utilities.h>
39
40 // SALOME GUI includes
41 #include <LightApp_Application.h>
42 #include <SUIT_MessageBox.h>
43 #include <SUIT_OverrideCursor.h>
44 #include <SUIT_ResourceMgr.h>
45 #include <SUIT_Session.h>
46 #include <SalomeApp_IntSpinBox.h>
47 #include <SalomeApp_Tools.h>
48 #include <SVTK_ViewWindow.h>
49
50 // Qt includes
51 #include <QFrame>
52 #include <QLineEdit>
53 #include <QLabel>
54 #include <QGroupBox>
55 #include <QVBoxLayout>
56
57 #define SPACING 6
58 #define MARGIN  11
59
60 SMESHGUI_GenericHypothesisCreator::SMESHGUI_GenericHypothesisCreator( const QString& theHypType )
61   : myToDeleteInitParamsHypo( false ),
62     myHypType( theHypType ),
63     myIsCreate( false ),
64     myDlg( 0 )
65 {
66 }
67
68 SMESHGUI_GenericHypothesisCreator::~SMESHGUI_GenericHypothesisCreator()
69 {
70   if ( myToDeleteInitParamsHypo && !myInitParamsHypo->_is_nil() )
71     myInitParamsHypo->UnRegister();
72 }
73
74 void SMESHGUI_GenericHypothesisCreator::setInitParamsHypothesis(SMESH::SMESH_Hypothesis_ptr hyp)
75 {
76   if ( !CORBA::is_nil( hyp ) ) {
77     if ( myToDeleteInitParamsHypo && !myInitParamsHypo->_is_nil() )
78       myInitParamsHypo->UnRegister();
79     CORBA::String_var hypName = hyp->GetName();
80     if ( hypType() == hypName.in() )
81     {
82       myInitParamsHypo         = SMESH::SMESH_Hypothesis::_duplicate( hyp );
83       myToDeleteInitParamsHypo = !SMESH::FindSObject( myInitParamsHypo );
84     }
85   }
86 }
87
88 void SMESHGUI_GenericHypothesisCreator::create( SMESH::SMESH_Hypothesis_ptr initParamsHyp,
89                                                 const QString& theHypName,
90                                                 QWidget* parent, QObject* obj, const QString& slot )
91 {
92   setInitParamsHypothesis( initParamsHyp );
93   create( false, theHypName, parent, obj, slot );
94 }
95
96 void SMESHGUI_GenericHypothesisCreator::create( bool           isAlgo,
97                                                 const QString& theHypName,
98                                                 QWidget*       theParent,
99                                                 QObject*       obj,
100                                                 const QString& slot )
101 {
102   myIsCreate = true;
103
104   // Create hypothesis/algorithm
105   if (isAlgo) {
106     SMESH::SMESH_Hypothesis_var anAlgo =
107       SMESH::CreateHypothesis( hypType(), theHypName, isAlgo );
108     anAlgo.out(); // avoid unused variable warning
109   }
110   else {
111     SMESH::SMESH_Hypothesis_var aHypothesis =
112       SMESH::CreateHypothesis( hypType(), theHypName, false );
113     editHypothesis( aHypothesis.in(), theHypName, theParent, obj, slot );
114   }
115 }
116
117 void SMESHGUI_GenericHypothesisCreator::edit( SMESH::SMESH_Hypothesis_ptr theHypothesis,
118                                               const QString&              theHypName,
119                                               QWidget* theParent, QObject* obj, const QString& slot )
120 {
121   if( CORBA::is_nil( theHypothesis ) )
122     return;
123
124   myIsCreate = false;
125
126   editHypothesis( theHypothesis, theHypName, theParent, obj, slot );
127 }
128
129 void SMESHGUI_GenericHypothesisCreator::editHypothesis( SMESH::SMESH_Hypothesis_ptr h,
130                                                         const QString& theHypName,
131                                                         QWidget* theParent,
132                                                         QObject* obj, const QString& slot )
133 {
134   myHypName = theHypName;
135   myHypo = SMESH::SMESH_Hypothesis::_duplicate( h );
136   myHypo->Register();
137
138   SMESHGUI_HypothesisDlg* Dlg = new SMESHGUI_HypothesisDlg( this, theParent );
139   connect( Dlg, SIGNAL( finished( int ) ), this, SLOT( onDialogFinished( int ) ) );
140   connect( this, SIGNAL( finished( int ) ), obj, slot.toLatin1().constData() );
141   connect( SMESHGUI::GetSMESHGUI(), SIGNAL( SignalCloseAllDialogs() ), Dlg, SLOT( reject() ));
142
143   myDlg = Dlg;
144   QFrame* fr = buildFrame();
145   if( fr )
146   {
147     Dlg->setCustomFrame( fr );
148     Dlg->setWindowTitle( caption() );
149     Dlg->setObjectName( theHypName );
150     Dlg->setHIcon( icon() );
151     if ( theHypName == HypothesesSet::getCommonHypoSetHypoType() )
152       Dlg->setType( tr( HypothesesSet::getCommonHypoSetHypoType()) );
153     else
154       Dlg->setType( type() );
155     retrieveParams();
156     Dlg->show(); // w/o this Dlg blocks selection
157     Dlg->resize( Dlg->minimumSizeHint() );
158     Dlg->exec(); // w/o this we cant wait until edition ends when applying a hypo-set
159   }
160   else {
161     emit finished( QDialog::Accepted );
162     delete myDlg;
163   }
164 }
165
166 QFrame* SMESHGUI_GenericHypothesisCreator::buildStdFrame()
167 {
168   if( CORBA::is_nil( hypothesis() ) )
169     return 0;
170
171   ListOfStdParams params;
172   if( !stdParams( params ) || params.isEmpty() )
173     return 0;
174
175   QFrame* fr = new QFrame( 0 );
176   QVBoxLayout* lay = new QVBoxLayout( fr );
177   lay->setMargin( 5 );
178   lay->setSpacing( 0 );
179
180   QGroupBox* GroupC1 = new QGroupBox( tr( "SMESH_ARGUMENTS" ), fr );
181   lay->addWidget( GroupC1 );
182
183   QGridLayout* GroupC1Layout = new QGridLayout( GroupC1 );
184   GroupC1Layout->setSpacing( SPACING );
185   GroupC1Layout->setMargin( MARGIN );
186
187   ListOfStdParams::const_iterator anIt = params.begin(), aLast = params.end();
188   for( int i = 0; anIt != aLast; anIt++, i++ )
189   {
190     QLabel* lab = anIt->hasName() ? new QLabel( anIt->myName, GroupC1 ) : NULL;
191     if ( lab )
192       GroupC1Layout->addWidget( lab, i, 0 );
193     myParamLabels << lab;
194
195     QWidget* w = getCustomWidget( *anIt, GroupC1, i );
196     if ( !w )
197       switch( (*anIt).myValue.type() )
198       {
199       case QVariant::Int:
200         {
201           SalomeApp_IntSpinBox* sb = new SalomeApp_IntSpinBox( GroupC1 );
202           sb->setObjectName( (*anIt).myName );
203           attuneStdWidget( sb, i );
204           sb->setValue( (*anIt).myValue.toInt() );
205           connect( sb, SIGNAL( valueChanged( int ) ), this, SLOT( onValueChanged() ) );
206           w = sb;
207         }
208         break;
209       case QVariant::Double:
210         {
211           SalomeApp_DoubleSpinBox* sb = new SMESHGUI_SpinBox( GroupC1 );
212           sb->setObjectName( (*anIt).myName );
213           attuneStdWidget( sb, i );
214           sb->setValue( (*anIt).myValue.toDouble() );
215           connect( sb, SIGNAL( valueChanged( double ) ), this, SLOT( onValueChanged() ) );
216           w = sb;
217         }
218         break;
219       case QVariant::String:
220         {
221           if((*anIt).isVariable) {
222             _PTR(Study) aStudy = SMESH::getStudy();
223             QString aVar = (*anIt).myValue.toString();
224             if(aStudy->IsInteger(aVar.toLatin1().constData())){
225               SalomeApp_IntSpinBox* sb = new SalomeApp_IntSpinBox( GroupC1 );
226               sb->setObjectName( (*anIt).myName );
227               attuneStdWidget( sb, i );
228               sb->setText( aVar );
229               connect( sb, SIGNAL( valueChanged( int ) ), this, SLOT( onValueChanged() ) );
230               w = sb;
231             }
232             else if(aStudy->IsReal(aVar.toLatin1().constData())){
233               SalomeApp_DoubleSpinBox* sb = new SMESHGUI_SpinBox( GroupC1 );
234               sb->setObjectName( (*anIt).myName );
235               attuneStdWidget( sb, i );
236               sb->setText( aVar );
237               connect( sb, SIGNAL( valueChanged( double ) ), this, SLOT( onValueChanged() ) );
238               w = sb;
239             }
240           }
241           else {
242             QLineEdit* le = new QLineEdit( GroupC1 );
243             le->setObjectName( (*anIt).myName );
244             attuneStdWidget( le, i );
245             le->setText( (*anIt).myValue.toString() );
246             connect( le, SIGNAL( textChanged( const QString& ) ), this, SLOT( onValueChanged() ) );
247             w = le;
248           }
249         }
250         break;
251
252       default:;
253       } // switch( (*anIt).myValue.type() )
254
255     if ( w )
256     {
257       if ( lab )
258         GroupC1Layout->addWidget( w, i, 1 );
259       else
260         GroupC1Layout->addWidget( w, i, 0, 1, 2 );
261       changeWidgets().append( w );
262     }
263   }
264   if ( QWidget* w = getHelperWidget() )
265   {
266     w->setParent( fr );
267     w->move( QPoint( 0, 0 ) );
268     lay->addWidget( w );
269   }
270
271   return fr;
272 }
273
274 void SMESHGUI_GenericHypothesisCreator::onValueChanged()
275 {
276   valueChanged( (QWidget*) sender() );
277 }
278
279 void SMESHGUI_GenericHypothesisCreator::valueChanged( QWidget* )
280 {
281 }
282
283 void SMESHGUI_GenericHypothesisCreator::onDialogFinished( int result )
284 {
285   bool res = result==QDialog::Accepted;
286   if( res )
287   {
288     try
289     {
290       SUIT_OverrideCursor wc;
291       storeParams();
292       // No longer needed since NoteBook appears and "Value" OB field shows names of variable
293       // QString paramValues = storeParams();
294       // if ( !paramValues.isEmpty() ) {
295       //   if ( _PTR(SObject) SHyp = SMESH::FindSObject( myHypo ))
296       //     SMESH::SetValue( SHyp, paramValues );
297       // }
298     }
299     catch ( const SALOME::SALOME_Exception& S_ex ) {
300       SalomeApp_Tools::QtCatchCorbaException( S_ex );
301     }
302   }
303
304   changeWidgets().clear();
305
306   if( myIsCreate && !res )
307   {
308     //remove just created hypothesis
309     _PTR(SObject) aHypSObject = SMESH::FindSObject( myHypo );
310     _PTR(Study) aStudy = SMESH::getStudy();
311     if( aStudy && !aStudy->GetProperties()->IsLocked() )
312     {
313       _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
314       aBuilder->RemoveObjectWithChildren( aHypSObject );
315     }
316   }
317   else if( !myIsCreate && res )
318   {
319     SMESH::SObjectList listSOmesh = SMESH::GetMeshesUsingAlgoOrHypothesis( myHypo );
320     if( listSOmesh.size() > 0 )
321       for( size_t i = 0; i < listSOmesh.size(); i++ )
322       {
323         _PTR(SObject) submSO = listSOmesh[i];
324         SMESH::SMESH_Mesh_var aMesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( submSO );
325         SMESH::SMESH_subMesh_var aSubMesh = SMESH::SObjectToInterface<SMESH::SMESH_subMesh>( submSO );
326         if( !aSubMesh->_is_nil() )
327           aMesh = aSubMesh->GetFather();
328         _PTR(SObject) meshSO = SMESH::FindSObject( aMesh );
329         SMESH_Actor* actor = SMESH::FindActorByEntry( meshSO->GetID().c_str() );
330         if( actor && actor->GetVisibility() )
331           actor->Update();
332       }
333   }
334   SMESHGUI::GetSMESHGUI()->updateObjBrowser( true, 0 );
335   myHypo->UnRegister();
336   myHypo = SMESH::SMESH_Hypothesis::_nil();
337   myInitParamsHypo = SMESH::SMESH_Hypothesis::_nil();
338
339   disconnect( myDlg, SIGNAL( finished( int ) ), this, SLOT( onDialogFinished( int ) ) );
340   myDlg->close();
341   //delete myDlg; since WA_DeleteOnClose==true
342   myDlg = 0;
343
344   SMESH::UpdateActorsAfterUpdateStudy();// remove actors of removed groups (#16522)
345   if (SVTK_ViewWindow* vf = SMESH::GetCurrentVtkView()) {
346     vf->Repaint();
347   }
348   emit finished( result );
349 }
350
351 bool SMESHGUI_GenericHypothesisCreator::stdParams( ListOfStdParams& ) const
352 {
353   return false;
354 }
355
356 bool SMESHGUI_GenericHypothesisCreator::getStdParamFromDlg( ListOfStdParams& params ) const
357 {
358   bool res = true;
359   StdParam item;
360   ListOfWidgets::const_iterator anIt = widgets().begin(), aLast = widgets().end();
361   for( ; anIt!=aLast; anIt++ )
362   {
363     item.myName = (*anIt)->objectName();
364     if( (*anIt)->inherits( "SalomeApp_IntSpinBox" ) )
365     {
366       SalomeApp_IntSpinBox* sb = ( SalomeApp_IntSpinBox* )( *anIt );
367       item.myValue = sb->value();
368       item.myText = sb->text();
369       params.append( item );
370     }
371     else if( (*anIt)->inherits( "SalomeApp_DoubleSpinBox" ) )
372     {
373       SalomeApp_DoubleSpinBox* sb = ( SalomeApp_DoubleSpinBox* )( *anIt );
374       item.myValue = sb->value();
375       item.myText = sb->text();
376       params.append( item );
377     }
378     else if( (*anIt)->inherits( "QLineEdit" ) )
379     {
380       QLineEdit* line = ( QLineEdit* )( *anIt );
381       item.myValue = item.myText = line->text();
382       params.append( item );
383     }
384     else if ( getParamFromCustomWidget( item, *anIt ))
385     {
386       params.append( item );
387     }
388     else
389       res = false;
390   }
391   return res;
392 }
393
394 QString SMESHGUI_GenericHypothesisCreator::getVariableName(const char* methodName) const
395 {
396   SMESH::SMESH_Hypothesis_var h = hypothesis();
397   if ( !h->_is_nil() )
398   {
399     CORBA::String_var aVaribaleName = h->GetVarParameter( methodName );
400     return QString( aVaribaleName.in() );
401   }
402   return QString();
403 }
404
405 QStringList SMESHGUI_GenericHypothesisCreator::getVariablesFromDlg() const
406 {
407   QStringList aResult;
408   ListOfWidgets::const_iterator anIt = widgets().begin(), aLast = widgets().end();
409   for( ; anIt!=aLast; anIt++ ) {
410     if( (*anIt)->inherits( "QAbstractSpinBox" ) ) {
411       QAbstractSpinBox* sb = ( QAbstractSpinBox* )( *anIt );
412       aResult.append(sb->text());
413     }
414   }
415   return aResult;
416 }
417
418 QString SMESHGUI_GenericHypothesisCreator::stdParamValues( const ListOfStdParams& params)
419 {
420   QString valueStr = "";
421   ListOfStdParams::const_iterator param = params.begin(), aLast = params.end();
422   int len0 = 0;
423   for ( ; param != aLast; param++ )
424   {
425     if ( valueStr.length() > len0 ) {
426       valueStr += "; ";
427       len0 = valueStr.length();
428     }
429     switch( (*param).myValue.type() )
430     {
431     case QVariant::Int:
432       valueStr += valueStr.number( (*param).myValue.toInt() );
433       break;
434     case QVariant::Double:
435       valueStr += valueStr.number( (*param).myValue.toDouble() );
436       break;
437     case QVariant::String:
438       valueStr += (*param).myValue.toString();
439       break;
440     default:
441       QVariant valCopy = (*param).myValue;
442       valueStr += valCopy.toString();
443     }
444   }
445   return valueStr;
446 }
447
448 SMESH::SMESH_Hypothesis_var SMESHGUI_GenericHypothesisCreator::hypothesis() const
449 {
450   return myHypo;
451 }
452
453 void SMESHGUI_GenericHypothesisCreator::setShapeEntry( const QString& theEntry )
454 {
455   myShapeEntry = theEntry;
456 }
457
458 //================================================================================
459 /*!
460  * \brief Return hypothesis containing initial parameters
461  *  \param strictly - if true, always return myInitParamsHypo,
462  *                    else, return myInitParamsHypo only in creation mode and if it
463  *                    is non-nil
464  */
465 //================================================================================
466
467 SMESH::SMESH_Hypothesis_var SMESHGUI_GenericHypothesisCreator::initParamsHypothesis(const bool strictly) const
468 {
469   if ( strictly )
470     return myInitParamsHypo;
471   if ( !isCreation() || CORBA::is_nil( myInitParamsHypo ))
472     return myHypo;
473   return myInitParamsHypo;
474 }
475
476 bool SMESHGUI_GenericHypothesisCreator::hasInitParamsHypothesis() const
477 {
478   return !CORBA::is_nil( myInitParamsHypo );
479 }
480
481 QString SMESHGUI_GenericHypothesisCreator::hypType() const
482 {
483   return myHypType;
484 }
485
486 QString SMESHGUI_GenericHypothesisCreator::hypName() const
487 {
488   return myHypName;
489 }
490
491 const SMESHGUI_GenericHypothesisCreator::ListOfWidgets& SMESHGUI_GenericHypothesisCreator::widgets() const
492 {
493   return myParamWidgets;
494 }
495
496 SMESHGUI_GenericHypothesisCreator::ListOfWidgets& SMESHGUI_GenericHypothesisCreator::changeWidgets()
497 {
498   return myParamWidgets;
499 }
500
501 //================================================================================
502 /*!
503  * \brief Returns a QLabel of a specified parameter.
504  * If isCreation(), the 1st label (supposed to be "Name") is not countered.
505  */
506 //================================================================================
507
508 QLabel* SMESHGUI_GenericHypothesisCreator::getLabel(int i) const
509 {
510   if ( isCreation() )
511     i++;
512   if ( i < myParamLabels.size() )
513     return (QLabel*) myParamLabels.at(i);
514   return NULL;
515 }
516
517 QtxDialog* SMESHGUI_GenericHypothesisCreator:: dlg() const
518 {
519   return myDlg;
520 }
521
522 bool SMESHGUI_GenericHypothesisCreator::isCreation() const
523 {
524   return myIsCreate;
525 }
526
527 void SMESHGUI_GenericHypothesisCreator::attuneStdWidget( QWidget*, const int ) const
528 {
529 }
530
531 QString SMESHGUI_GenericHypothesisCreator::caption() const
532 {
533   return QString();
534 }
535
536 QPixmap SMESHGUI_GenericHypothesisCreator::icon() const
537 {
538   return QPixmap();
539 }
540
541 QString SMESHGUI_GenericHypothesisCreator::type() const
542 {
543   return QString();
544 }
545 QWidget* SMESHGUI_GenericHypothesisCreator::getCustomWidget( const StdParam & /*param*/,
546                                                              QWidget*   /*parent*/,
547                                                              const int  /*index*/) const
548 {
549   return 0;
550 }
551 //================================================================================
552 /*!
553  * \brief Returns a widget representing not a hypothesis parameter but some helper widget
554  */
555 //================================================================================
556
557 QWidget* SMESHGUI_GenericHypothesisCreator::getHelperWidget() const
558 {
559   return 0;
560 }
561
562 bool SMESHGUI_GenericHypothesisCreator::getParamFromCustomWidget( StdParam&, QWidget* ) const
563 {
564   return false;
565 }
566
567 bool SMESHGUI_GenericHypothesisCreator::checkParams( QString& msg ) const
568 {
569   bool ok = true;
570   ListOfWidgets::const_iterator anIt = widgets().begin(), aLast = widgets().end();
571   for( ; anIt!=aLast; anIt++ )
572   {
573     if( (*anIt)->inherits( "SalomeApp_IntSpinBox" ) )
574     {
575       SalomeApp_IntSpinBox* sb = ( SalomeApp_IntSpinBox* )( *anIt );
576       ok = sb->isValid( msg, true ) && ok;
577     }
578     else if( (*anIt)->inherits( "SalomeApp_DoubleSpinBox" ) )
579     {
580       SalomeApp_DoubleSpinBox* sb = ( SalomeApp_DoubleSpinBox* )( *anIt );
581       ok = sb->isValid( msg, true ) && ok;
582     }
583   }
584   return ok;
585 }
586
587 void SMESHGUI_GenericHypothesisCreator::onReject()
588 {
589 }
590
591 QString SMESHGUI_GenericHypothesisCreator::helpPage() const
592 {
593   QString aHypType = hypType();
594   QString aHelpFileName = "";
595   if ( aHypType == "LocalLength" )
596     aHelpFileName = "1d_meshing_hypo.html#average-length-anchor";
597   else if ( aHypType == "MaxLength" )
598     aHelpFileName = "1d_meshing_hypo.html#max-length-anchor";
599   else if ( aHypType == "Arithmetic1D")
600     aHelpFileName = "1d_meshing_hypo.html#arithmetic-1d-anchor";
601   else if ( aHypType == "GeometricProgression")
602     aHelpFileName = "1d_meshing_hypo.html#geometric-1d-anchor";
603   else if ( aHypType == "FixedPoints1D")
604     aHelpFileName = "1d_meshing_hypo.html#fixed-points-1d-anchor";
605   else if ( aHypType == "MaxElementArea")
606     aHelpFileName = "2d_meshing_hypo.html#max-element-area-anchor";
607   else if ( aHypType == "MaxElementVolume")
608     aHelpFileName = "3d_meshing_hypo.html#max-element-volume-hypothesis";
609   else if ( aHypType == "StartEndLength")
610     aHelpFileName = "1d_meshing_hypo.html#start-and-end-length-anchor";
611   else if ( aHypType == "Deflection1D")
612     aHelpFileName = "1d_meshing_hypo.html#deflection-1d-anchor";
613   else if ( aHypType == "Adaptive1D")
614     aHelpFileName = "1d_meshing_hypo.html#adaptive-1d-anchor";
615   else if ( aHypType == "AutomaticLength")
616     aHelpFileName = "1d_meshing_hypo.html#automatic-length-anchor";
617   else if ( aHypType == "NumberOfSegments")
618     aHelpFileName = "1d_meshing_hypo.html#number-of-segments-anchor";
619   else if ( aHypType == "ProjectionSource1D")
620     aHelpFileName = "projection_algos.html";
621   else if ( aHypType == "ProjectionSource2D")
622     aHelpFileName = "projection_algos.html";
623   else if ( aHypType == "ProjectionSource3D")
624     aHelpFileName = "projection_algos.html";
625   else if ( aHypType == "NumberOfLayers")
626     aHelpFileName = "radial_prism_algo.html";
627   else if ( aHypType == "NumberOfLayers2D")
628     aHelpFileName = "radial_quadrangle_1D2D_algo.html";
629   else if ( aHypType == "LayerDistribution")
630     aHelpFileName = "radial_prism_algo.html";
631   else if ( aHypType == "LayerDistribution2D")
632     aHelpFileName = "radial_quadrangle_1D2D_algo.html";
633   else if ( aHypType == "SegmentLengthAroundVertex")
634     aHelpFileName = "segments_around_vertex_algo.html";
635   else if ( aHypType == "QuadrangleParams")
636     aHelpFileName = "2d_meshing_hypo.html#hypo-quad-params-anchor";
637   else if ( aHypType == "ViscousLayers")
638     aHelpFileName = "additional_hypo.html#viscous-layers-anchor";
639   else if ( aHypType == "ViscousLayers2D")
640     aHelpFileName = "additional_hypo.html#viscous-layers-anchor";
641   else if ( aHypType == "ImportSource1D" || aHypType == "ImportSource2D")
642     aHelpFileName = "use_existing_algos.html";
643   return aHelpFileName;
644 }
645
646 SMESHGUI_HypothesisDlg::SMESHGUI_HypothesisDlg( SMESHGUI_GenericHypothesisCreator* creator, QWidget* parent )
647 : QtxDialog( parent, false, true ),
648   myCreator( creator )
649 {
650   setAttribute(Qt::WA_DeleteOnClose, true);
651  // setMinimumSize( 300, height() );
652 //  setFixedSize( 300, height() );
653   QVBoxLayout* topLayout = new QVBoxLayout( mainFrame() );
654   topLayout->setMargin( 0 );
655   topLayout->setSpacing( 0 );
656
657   QFrame* titFrame = new QFrame( mainFrame() );
658   QHBoxLayout* titLay = new QHBoxLayout( titFrame );
659   titLay->setMargin( 0 );
660   titLay->setSpacing( SPACING );
661
662   myIconLabel = new QLabel( titFrame );
663   myIconLabel->setScaledContents( false );
664   myIconLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
665   myTypeLabel = new QLabel( titFrame );
666   if( creator )
667     myTypeLabel->setText( creator->hypType() );
668
669   titLay->addWidget( myIconLabel, 0 );
670   titLay->addWidget( myTypeLabel, 0 );
671   titLay->addStretch( 1 );
672
673   topLayout->addWidget( titFrame, 0 );
674
675   myHelpFileName = creator->helpPage();
676
677   connect( this, SIGNAL( dlgHelp() ), this, SLOT( onHelp() ) );
678 }
679
680 SMESHGUI_HypothesisDlg::~SMESHGUI_HypothesisDlg()
681 {
682   delete myCreator;
683 }
684
685 void SMESHGUI_HypothesisDlg::showEvent(QShowEvent *event)
686 {
687   // resize( minimumSizeHint() );
688   // adjustSize();
689
690   QtxDialog::showEvent( event );
691 }
692
693 void SMESHGUI_HypothesisDlg::setCustomFrame( QFrame* f )
694 {
695   if( f )
696   {
697     f->setParent( mainFrame() );
698     qobject_cast<QVBoxLayout*>( mainFrame()->layout() )->insertWidget( 1, f, 1 );
699   }
700 }
701
702 void SMESHGUI_HypothesisDlg::accept()
703 {
704   SUIT_OverrideCursor wc; // some creators temporary set params to a hyp which can be long
705   QString msg;
706   if ( myCreator && !myCreator->checkParams( msg ) )
707   {
708     QString str( tr( "SMESH_INCORRECT_INPUT" ) );
709     if ( !msg.isEmpty() )
710       str += "\n" + msg;
711     SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
712     return;
713   }
714   QtxDialog::accept();
715 }
716
717 void SMESHGUI_HypothesisDlg::reject()
718 {
719   if ( myCreator ) myCreator->onReject();
720   QtxDialog::reject();
721 }
722
723 void SMESHGUI_HypothesisDlg::onHelp()
724 {
725   LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
726   if (app) {
727     QString name = "SMESH";
728     if(myCreator) {
729       QVariant pluginName = myCreator->property( SMESH::Plugin_Name() );
730       if( pluginName.isValid() ) {
731         QString rootDir = pluginName.toString() + "PLUGIN_ROOT_DIR";
732         QString varValue = QString( getenv(rootDir.toLatin1().constData()));
733         if(!varValue.isEmpty())
734           name = pluginName.toString() + "PLUGIN";
735       }
736     }    
737     app->onHelpContextModule(name, myHelpFileName);
738   }
739   else {
740     QString platform;
741 #ifdef WIN32
742     platform = "winapplication";
743 #else
744     platform = "application";
745 #endif
746     SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
747                              tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
748                              arg(app->resourceMgr()->stringValue("ExternalBrowser",
749                                                                  platform)).
750                              arg(myHelpFileName));
751   }
752 }
753
754 void SMESHGUI_HypothesisDlg::setHIcon( const QPixmap& p )
755 {
756   myIconLabel->setPixmap( p );
757 }
758
759 void SMESHGUI_HypothesisDlg::setType( const QString& t )
760 {
761   myTypeLabel->setText( t );
762 }
763
764 HypothesisData::HypothesisData( const QString&     theTypeName,
765                                 const QString&     thePluginName,
766                                 const QString&     theServerLibName,
767                                 const QString&     theClientLibName,
768                                 const QString&     theLabel,
769                                 const QString&     theIconId,
770                                 const QString&     theContext,
771                                 const int          theGroupID,
772                                 const int          thePriority,
773                                 const QList<int>&  theDim,
774                                 const bool         theIsAuxOrNeedHyp,
775                                 const QStringList& theBasicHypos,
776                                 const QStringList& theOptionalHypos,
777                                 const QStringList& theInputTypes,
778                                 const QStringList& theOutputTypes,
779                                 const int          theIsNeedGeometry,
780                                 const bool         theSupportSub)
781   : TypeName( theTypeName ),
782     PluginName( thePluginName ),
783     ServerLibName( theServerLibName ),
784     ClientLibName( theClientLibName ),
785     Label( theLabel ),
786     IconId( theIconId ),
787     Context( theContext ),
788     GroupID( theGroupID ),
789     Priority( thePriority ),
790     Dim( theDim ),
791     IsAuxOrNeedHyp( theIsAuxOrNeedHyp ),
792     IsNeedGeometry( theIsNeedGeometry ),
793     IsSupportSubmeshes( theSupportSub ),
794     BasicHypos( theBasicHypos ),
795     OptionalHypos( theOptionalHypos ),
796     InputTypes( theInputTypes ),
797     OutputTypes( theOutputTypes )
798 {
799 }
800
801 // HypothesesSet::HypothesesSet( const QString& theSetName )
802 //   : myHypoSetName( theSetName ),
803 //     myIsAlgo( false ),
804 //     myIsCustom( false )
805 // {
806 // }
807
808 HypothesesSet::HypothesesSet( const QString& theSetName,
809                               bool useCommonSize, bool isQuadDominated,
810                               const QStringList& mainHypos, const QStringList& mainAlgos,
811                               const QStringList& altHypos,  const QStringList& altAlgos,
812                               const QStringList& intHypos,  const QStringList& intAlgos )
813   : myUseCommonSize( useCommonSize ),
814     myQuadDominated( isQuadDominated ),
815     myHypoSetName( theSetName ),
816     myHypoList { mainHypos, altHypos, intHypos },
817     myAlgoList { mainAlgos, altAlgos, intAlgos },
818     myIsAlgo( false ),
819     myIsCustom( false ),
820     myIndex( 0 )
821 {
822   for ( myHypType = MAIN; myHypType < NB_HYP_TYPES; SMESHUtils::Increment( myHypType ))
823     for ( int isAlgo = myIsAlgo = 0; isAlgo < 2; myIsAlgo = ++isAlgo )
824     {
825       QStringList& hyps = *list();
826       for ( int i = 0; i < hyps.count(); ++i )
827         hyps[ i ] = hyps[ i ].trimmed();
828     }
829 }
830
831 QStringList* HypothesesSet::list( bool is_algo, SetType setType) const
832 {
833   return const_cast<QStringList*>( &( is_algo ? myAlgoList[setType] : myHypoList[setType] ));
834 }
835
836 QStringList* HypothesesSet::list() const
837 {
838   return list( myIsAlgo, myHypType );
839 }
840
841 QString HypothesesSet::name() const
842 {
843   return myHypoSetName;
844 }
845
846 // void HypothesesSet::set( bool isAlgo, const QStringList& lst )
847 // {
848 //   *list(isAlgo) = lst;
849 // }
850
851 // int HypothesesSet::count( bool isAlgo, SetType setType ) const
852 // {
853 //   return list(isAlgo,setType)->count();
854 // }
855
856 // bool HypothesesSet::isAlgo() const
857 // {
858 //   return myIsAlgo;
859 // }
860
861 void HypothesesSet::init( bool isAlgo, SetType setType )
862 {
863   myHypType = setType;
864   myIsAlgo = isAlgo;
865   myIndex = 0;
866 }
867
868 bool HypothesesSet::more() const
869 {
870   return myIndex < list()->count();
871 }
872
873 void HypothesesSet::next()
874 {
875   myIndex++;
876 }
877
878 QString HypothesesSet::current() const
879 {
880   return list()->at(myIndex);
881 }
882
883 void HypothesesSet::setIsCustom( bool isCustom )
884 {
885   myIsCustom = isCustom;
886 }
887
888 bool HypothesesSet::getIsCustom() const
889 {
890   return myIsCustom;
891 }
892
893 void HypothesesSet::setAlgoAvailable( SetType type, bool isAvailable )
894 {
895   if ( MAIN <= type && type < NB_HYP_TYPES )
896     myIsAlgoAvailable[ type ] = isAvailable;
897 }
898
899 bool HypothesesSet::getAlgoAvailable( SetType type )
900 {
901   bool isAva = false;
902   if ( MAIN <= type && type < NB_HYP_TYPES )
903     isAva = myIsAlgoAvailable[ type ];
904   return isAva;
905 }
906
907 HypothesesSet::SetType HypothesesSet::getPreferredHypType()
908 {
909   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
910   int useAltHypos = !resMgr->booleanValue( "SMESH", "use-meshgems-hypo-sets", false );
911   return ( HypothesesSet::SetType ) useAltHypos;
912 }
913
914 int HypothesesSet::maxDim() const
915 {
916   HypothesesSet * thisSet = (HypothesesSet*) this;
917   int dim = -1;
918   for ( int setType = 0; setType < 2; ++setType )
919     for ( int isAlgo = 0; isAlgo < 2; ++isAlgo )
920     {
921       for ( thisSet->init( isAlgo, SetType( setType )); thisSet->more(); thisSet->next() )
922         if ( HypothesisData* hypData = SMESH::GetHypothesisData( thisSet->current() ))
923           for ( int i = 0; i < hypData->Dim.count(); ++i )
924             dim = qMax( dim, hypData->Dim[i] );
925     }
926   return dim;
927 }
928
929 const char* HypothesesSet::getCommonHypoSetHypoType()
930 {
931   return "AverageLengthForHypoSet";
932 }