src/SMESHGUI/SMESHGUI_Hypotheses.cxx

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