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