src/SMESHGUI/SMESHGUI_Hypotheses.cxx

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