src/SMESHGUI/SMESHGUI_Hypotheses.cxx

   1 // SMESH SMESHGUI : GUI for SMESH component
   2 //
   3 // Copyright (C) 2003  CEA
   4 //
   5 // This library is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU Lesser General Public
   7 // License as published by the Free Software Foundation; either
   8 // version 2.1 of the License.
   9 //
  10 // This library is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // Lesser General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Lesser General Public
  16 // License along with this library; if not, write to the Free Software
  17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 //
  19 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 //
  21 // File   : SMESHGUI_Hypotheses.cxx
  22 // Author : Julia DOROVSKIKH, Open CASCADE S.A.S.
  23 //
  24
  25 // SMESH includes
  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 <QtxIntSpinBox.h>
  39 #include <SUIT_Session.h>
  40 #include <SUIT_MessageBox.h>
  41 #include <SUIT_ResourceMgr.h>
  42 #include <LightApp_Application.h>
  43
  44 // Qt includes
  45 #include <QFrame>
  46 #include <QLineEdit>
  47 #include <QLabel>
  48 #include <QGroupBox>
  49 #include <QVBoxLayout>
  50 #include <QEventLoop>
  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 ), myEventLoop( 0 )
  57 {
  58 }
  59
  60 SMESHGUI_GenericHypothesisCreator::~SMESHGUI_GenericHypothesisCreator()
  61 {
  62 }
  63
  64 void SMESHGUI_GenericHypothesisCreator::create( SMESH::SMESH_Hypothesis_ptr initParamsHyp,
  65                                                 const QString& theHypName,
  66                                                 QWidget* parent)
  67 {
  68   MESSAGE( "Creation of hypothesis with initial params" );
  69
  70   if ( !CORBA::is_nil( initParamsHyp ) && hypType() == initParamsHyp->GetName() )
  71     myInitParamsHypo = SMESH::SMESH_Hypothesis::_duplicate( initParamsHyp );
  72   create( false, theHypName, parent );
  73 }
  74
  75 void SMESHGUI_GenericHypothesisCreator::create( bool isAlgo,
  76                                                 const QString& theHypName,
  77                                                 QWidget* theParent )
  78 {
  79   MESSAGE( "Creation of hypothesis" );
  80
  81   myIsCreate = true;
  82
  83   // Create hypothesis/algorithm
  84   if (isAlgo)
  85     SMESH::CreateHypothesis( hypType(), theHypName, isAlgo );
  86   else
  87   {
  88     SMESH::SMESH_Hypothesis_var aHypothesis =
  89       SMESH::CreateHypothesis( hypType(), theHypName, false );
  90     if( !editHypothesis( aHypothesis.in(), theHypName, theParent ) )
  91     { //remove just created hypothesis
  92       _PTR(SObject) aHypSObject = SMESH::FindSObject( aHypothesis.in() );
  93       _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
  94       if( aStudy && !aStudy->GetProperties()->IsLocked() )
  95       {
  96         _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
  97         aBuilder->RemoveObjectWithChildren( aHypSObject );
  98       }
  99     }
 100   }
 101   SMESHGUI::GetSMESHGUI()->updateObjBrowser( true, 0 );
 102 }
 103
 104 void SMESHGUI_GenericHypothesisCreator::edit( SMESH::SMESH_Hypothesis_ptr theHypothesis,
 105                                               const QString& theHypName,
 106                                               QWidget* theParent )
 107 {
 108   if( CORBA::is_nil( theHypothesis ) )
 109     return;
 110
 111   MESSAGE("Edition of hypothesis");
 112
 113   myIsCreate = false;
 114
 115   if( !editHypothesis( theHypothesis, theHypName, theParent ) )
 116     return;
 117
 118   SMESH::SObjectList listSOmesh = SMESH::GetMeshesUsingAlgoOrHypothesis( theHypothesis );
 119   if( listSOmesh.size() > 0 )
 120     for( int i = 0; i < listSOmesh.size(); i++ )
 121     {
 122       _PTR(SObject) submSO = listSOmesh[i];
 123       SMESH::SMESH_Mesh_var aMesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( submSO );
 124       SMESH::SMESH_subMesh_var aSubMesh = SMESH::SObjectToInterface<SMESH::SMESH_subMesh>( submSO );
 125       if( !aSubMesh->_is_nil() )
 126         aMesh = aSubMesh->GetFather();
 127       _PTR(SObject) meshSO = SMESH::FindSObject( aMesh );
 128       SMESH::ModifiedMesh( meshSO, false, aMesh->NbNodes()==0);
 129     }
 130   SMESHGUI::GetSMESHGUI()->updateObjBrowser( true, 0 );
 131 }
 132
 133 bool SMESHGUI_GenericHypothesisCreator::editHypothesis( SMESH::SMESH_Hypothesis_ptr h,
 134                                                         const QString& theHypName,
 135                                                         QWidget* theParent )
 136 {
 137   if( CORBA::is_nil( h ) )
 138     return false;
 139
 140   bool res = true;
 141   myHypName = theHypName;
 142   myHypo = SMESH::SMESH_Hypothesis::_duplicate( h );
 143
 144   SMESHGUI_HypothesisDlg* Dlg = new SMESHGUI_HypothesisDlg( this, theParent );
 145   connect( Dlg, SIGNAL( finished( int ) ), this, SLOT( onDialogFinished( int ) ) );
 146   myDlg = Dlg;
 147   QFrame* fr = buildFrame();
 148   if( fr )
 149   {
 150     Dlg->setCustomFrame( fr );
 151     Dlg->setWindowTitle( caption() );
 152     Dlg->setObjectName( theHypName );
 153     Dlg->setHIcon( icon() );
 154     Dlg->setType( type() );
 155     retrieveParams();
 156     Dlg->show();
 157     if ( !myEventLoop )
 158       myEventLoop = new QEventLoop( this );
 159     myEventLoop->exec(); // make myDlg not modal
 160     res = myDlg->result();
 161     if( res ) {
 162       QString paramValues = storeParams();
 163       if ( !paramValues.isEmpty() ) {
 164         if ( _PTR(SObject) SHyp = SMESH::FindSObject( myHypo ))
 165           SMESH::SetValue( SHyp, paramValues );
 166       }
 167     }
 168   }
 169   delete Dlg; myDlg = 0;
 170   changeWidgets().clear();
 171   myHypo = SMESH::SMESH_Hypothesis::_nil();
 172   myInitParamsHypo = SMESH::SMESH_Hypothesis::_nil();
 173   return res;
 174 }
 175
 176 QFrame* SMESHGUI_GenericHypothesisCreator::buildStdFrame()
 177 {
 178   if( CORBA::is_nil( hypothesis() ) )
 179     return 0;
 180
 181   ListOfStdParams params;
 182   if( !stdParams( params ) || params.isEmpty() )
 183     return 0;
 184
 185   QFrame* fr = new QFrame( 0 );
 186   QVBoxLayout* lay = new QVBoxLayout( fr );
 187   lay->setMargin( 5 );
 188   lay->setSpacing( 0 );
 189
 190   QGroupBox* GroupC1 = new QGroupBox( tr( "SMESH_ARGUMENTS" ), fr );
 191   lay->addWidget( GroupC1 );
 192
 193   QGridLayout* GroupC1Layout = new QGridLayout( GroupC1 );
 194   GroupC1Layout->setSpacing( SPACING );
 195   GroupC1Layout->setMargin( MARGIN );
 196
 197   ListOfStdParams::const_iterator anIt = params.begin(), aLast = params.end();
 198   for( int i=0; anIt!=aLast; anIt++, i++ )
 199   {
 200     QLabel* lab = new QLabel( (*anIt).myName, GroupC1 );
 201     GroupC1Layout->addWidget( lab, i, 0 );
 202
 203     QWidget* w = getCustomWidget( *anIt, GroupC1, i );
 204     if ( !w )
 205       switch( (*anIt).myValue.type() )
 206       {
 207       case QVariant::Int:
 208         {
 209           QtxIntSpinBox* sb = new QtxIntSpinBox( GroupC1 );
 210           sb->setObjectName( (*anIt).myName );
 211           attuneStdWidget( sb, i );
 212           sb->setValue( (*anIt).myValue.toInt() );
 213           connect( sb, SIGNAL( valueChanged( int ) ), this, SLOT( onValueChanged() ) );
 214           w = sb;
 215         }
 216         break;
 217       case QVariant::Double:
 218         {
 219           QtxDoubleSpinBox* sb = new SMESHGUI_SpinBox( GroupC1 );
 220           sb->setObjectName( (*anIt).myName );
 221           attuneStdWidget( sb, i );
 222           sb->setValue( (*anIt).myValue.toDouble() );
 223           connect( sb, SIGNAL( valueChanged( double ) ), this, SLOT( onValueChanged() ) );
 224           w = sb;
 225         }
 226         break;
 227       case QVariant::String:
 228         {
 229           QLineEdit* le = new QLineEdit( GroupC1 );
 230           le->setObjectName( (*anIt).myName );
 231           attuneStdWidget( le, i );
 232           le->setText( (*anIt).myValue.toString() );
 233           connect( le, SIGNAL( textChanged( const QString& ) ), this, SLOT( onValueChanged() ) );
 234           w = le;
 235         }
 236         break;
 237       }
 238
 239     if( w )
 240     {
 241       GroupC1Layout->addWidget( w, i, 1 );
 242       changeWidgets().append( w );
 243     }
 244   }
 245
 246   return fr;
 247 }
 248
 249 void SMESHGUI_GenericHypothesisCreator::onValueChanged()
 250 {
 251 }
 252
 253 void SMESHGUI_GenericHypothesisCreator::onDialogFinished( int /*result*/ )
 254 {
 255   if ( myEventLoop )
 256     myEventLoop->exit();
 257 }
 258
 259 bool SMESHGUI_GenericHypothesisCreator::stdParams( ListOfStdParams& ) const
 260 {
 261   return false;
 262 }
 263
 264 bool SMESHGUI_GenericHypothesisCreator::getStdParamFromDlg( ListOfStdParams& params ) const
 265 {
 266   bool res = true;
 267   StdParam item;
 268   ListOfWidgets::const_iterator anIt = widgets().begin(), aLast = widgets().end();
 269   for( ; anIt!=aLast; anIt++ )
 270   {
 271     item.myName = (*anIt)->objectName();
 272     if( (*anIt)->inherits( "QtxIntSpinBox" ) )
 273     {
 274       QtxIntSpinBox* sb = ( QtxIntSpinBox* )( *anIt );
 275       item.myValue = sb->value();
 276       params.append( item );
 277     }
 278
 279     else if( (*anIt)->inherits( "QtxDoubleSpinBox" ) )
 280     {
 281       QtxDoubleSpinBox* sb = ( QtxDoubleSpinBox* )( *anIt );
 282       item.myValue = sb->value();
 283       params.append( item );
 284     }
 285
 286     else if( (*anIt)->inherits( "QLineEdit" ) )
 287     {
 288       QLineEdit* line = ( QLineEdit* )( *anIt );
 289       item.myValue = line->text();
 290       params.append( item );
 291     }
 292
 293     else if ( getParamFromCustomWidget( item, *anIt ))
 294     {
 295       params.append( item );
 296     }
 297
 298     else
 299       res = false;
 300   }
 301   return res;
 302 }
 303
 304 QString SMESHGUI_GenericHypothesisCreator::stdParamValues( const ListOfStdParams& params)
 305 {
 306   QString valueStr = "";
 307   ListOfStdParams::const_iterator param = params.begin(), aLast = params.end();
 308   uint len0 = 0;
 309   for( int i=0; param!=aLast; param++, i++ )
 310   {
 311     if ( valueStr.length() > len0 ) {
 312       valueStr += "; ";
 313       len0 = valueStr.length();
 314     }
 315     switch( (*param).myValue.type() )
 316     {
 317     case QVariant::Int:
 318       valueStr += valueStr.number( (*param).myValue.toInt() );
 319       break;
 320     case QVariant::Double:
 321       valueStr += valueStr.number( (*param).myValue.toDouble() );
 322       break;
 323     case QVariant::String:
 324       valueStr += (*param).myValue.toString();
 325       break;
 326     default:
 327       QVariant valCopy = (*param).myValue;
 328       valueStr += valCopy.toString();
 329     }
 330   }
 331   return valueStr;
 332 }
 333
 334 SMESH::SMESH_Hypothesis_var SMESHGUI_GenericHypothesisCreator::hypothesis() const
 335 {
 336   return myHypo;
 337 }
 338
 339 SMESH::SMESH_Hypothesis_var SMESHGUI_GenericHypothesisCreator::initParamsHypothesis() const
 340 {
 341   if ( CORBA::is_nil( myInitParamsHypo ))
 342     return myHypo;
 343   return myInitParamsHypo;
 344 }
 345
 346 QString SMESHGUI_GenericHypothesisCreator::hypType() const
 347 {
 348   return myHypType;
 349 }
 350
 351 QString SMESHGUI_GenericHypothesisCreator::hypName() const
 352 {
 353   return myHypName;
 354 }
 355
 356 const SMESHGUI_GenericHypothesisCreator::ListOfWidgets& SMESHGUI_GenericHypothesisCreator::widgets() const
 357 {
 358   return myParamWidgets;
 359 }
 360
 361 SMESHGUI_GenericHypothesisCreator::ListOfWidgets& SMESHGUI_GenericHypothesisCreator::changeWidgets()
 362 {
 363   return myParamWidgets;
 364 }
 365
 366 QtxDialog* SMESHGUI_GenericHypothesisCreator:: dlg() const
 367 {
 368   return myDlg;
 369 }
 370
 371 bool SMESHGUI_GenericHypothesisCreator::isCreation() const
 372 {
 373   return myIsCreate;
 374 }
 375
 376 void SMESHGUI_GenericHypothesisCreator::attuneStdWidget( QWidget*, const int ) const
 377 {
 378 }
 379
 380 QString SMESHGUI_GenericHypothesisCreator::caption() const
 381 {
 382   return QString();
 383 }
 384
 385 QPixmap SMESHGUI_GenericHypothesisCreator::icon() const
 386 {
 387   return QPixmap();
 388 }
 389
 390 QString SMESHGUI_GenericHypothesisCreator::type() const
 391 {
 392   return QString();
 393 }
 394 QWidget* SMESHGUI_GenericHypothesisCreator::getCustomWidget( const StdParam & /*param*/,
 395                                                              QWidget*   /*parent*/,
 396                                                              const int  /*index*/) const
 397 {
 398   return 0;
 399 }
 400 bool SMESHGUI_GenericHypothesisCreator::getParamFromCustomWidget( StdParam&, QWidget* ) const
 401 {
 402   return false;
 403 }
 404
 405 void SMESHGUI_GenericHypothesisCreator::onReject()
 406 {
 407 }
 408
 409
 410
 411
 412 SMESHGUI_HypothesisDlg::SMESHGUI_HypothesisDlg( SMESHGUI_GenericHypothesisCreator* creator, QWidget* parent )
 413 : QtxDialog( parent, false, true ),
 414   myCreator( creator )
 415 {
 416   setMinimumSize( 300, height() );
 417 //  setFixedSize( 300, height() );
 418   QVBoxLayout* topLayout = new QVBoxLayout( mainFrame() );
 419   topLayout->setMargin( 0 );
 420   topLayout->setSpacing( 0 );
 421
 422   QFrame* titFrame = new QFrame( mainFrame() );
 423   QHBoxLayout* titLay = new QHBoxLayout( titFrame );
 424   titLay->setMargin( 0 );
 425   titLay->setSpacing( SPACING );
 426
 427   myIconLabel = new QLabel( titFrame );
 428   myIconLabel->setScaledContents( false );
 429   myIconLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
 430   myTypeLabel = new QLabel( titFrame );
 431   if( creator )
 432     myTypeLabel->setText( creator->hypType() );
 433
 434   titLay->addWidget( myIconLabel, 0 );
 435   titLay->addWidget( myTypeLabel, 0 );
 436   titLay->addStretch( 1 );
 437
 438   topLayout->addWidget( titFrame, 0 );
 439
 440   QString aHypType = creator->hypType();
 441   if ( aHypType == "LocalLength" )
 442     myHelpFileName = "a1d_meshing_hypo_page.html#average_length_anchor";
 443   else if ( aHypType == "Arithmetic1D")
 444     myHelpFileName = "a1d_meshing_hypo_page.html#arithmetic_1d_anchor";
 445   else if ( aHypType == "MaxElementArea")
 446     myHelpFileName = "a2d_meshing_hypo_page.html#max_element_area_anchor";
 447   else if ( aHypType == "MaxElementVolume")
 448     myHelpFileName = "max_element_volume_hypo_page.html";
 449   else if ( aHypType == "StartEndLength")
 450     myHelpFileName = "a1d_meshing_hypo_page.html#start_and_end_length_anchor";
 451   else if ( aHypType == "Deflection1D")
 452     myHelpFileName = "a1d_meshing_hypo_page.html#deflection_1d_anchor";
 453   else if ( aHypType == "AutomaticLength")
 454     myHelpFileName = "a1d_meshing_hypo_page.html#automatic_length_anchor";
 455   else if ( aHypType == "NumberOfSegments")
 456     myHelpFileName = "a1d_meshing_hypo_page.html#number_of_segments_anchor";
 457   else
 458     myHelpFileName = "";
 459
 460   connect( this, SIGNAL( dlgHelp() ), this, SLOT( onHelp() ) );
 461 }
 462
 463 SMESHGUI_HypothesisDlg::~SMESHGUI_HypothesisDlg()
 464 {
 465 }
 466
 467 void SMESHGUI_HypothesisDlg::setCustomFrame( QFrame* f )
 468 {
 469   if( f )
 470   {
 471     f->setParent( mainFrame() );
 472     qobject_cast<QVBoxLayout*>( layout() )->insertWidget( 1, f, 1 );
 473   }
 474 }
 475
 476 void SMESHGUI_HypothesisDlg::accept()
 477 {
 478   if ( myCreator && !myCreator->checkParams() )
 479     return;
 480   QtxDialog::accept();
 481 }
 482
 483 void SMESHGUI_HypothesisDlg::reject()
 484 {
 485   if ( myCreator ) myCreator->onReject();
 486   QtxDialog::reject();
 487 }
 488
 489 void SMESHGUI_HypothesisDlg::onHelp()
 490 {
 491   LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
 492   if (app) {
 493     SMESHGUI* aSMESHGUI = dynamic_cast<SMESHGUI*>( app->activeModule() );
 494     app->onHelpContextModule(aSMESHGUI ? app->moduleName(aSMESHGUI->moduleName()) : QString(""), myHelpFileName);
 495   }
 496   else {
 497     QString platform;
 498 #ifdef WIN32
 499     platform = "winapplication";
 500 #else
 501     platform = "application";
 502 #endif
 503     SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
 504                              tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
 505                              arg(app->resourceMgr()->stringValue("ExternalBrowser",
 506                                                                  platform)).
 507                              arg(myHelpFileName));
 508   }
 509 }
 510
 511 void SMESHGUI_HypothesisDlg::setHIcon( const QPixmap& p )
 512 {
 513   myIconLabel->setPixmap( p );
 514 }
 515
 516 void SMESHGUI_HypothesisDlg::setType( const QString& t )
 517 {
 518   myTypeLabel->setText( t );
 519 }
 520
 521 HypothesisData::HypothesisData( const QString& theTypeName,
 522                                 const QString& thePluginName,
 523                                 const QString& theServerLibName,
 524                                 const QString& theClientLibName,
 525                                 const QString& theLabel,
 526                                 const QString& theIconId,
 527                                 const QList<int>& theDim,
 528                                 const bool theIsAux,
 529                                 const QStringList& theNeededHypos,
 530                                 const QStringList& theOptionalHypos,
 531                                 const QStringList& theInputTypes,
 532                                 const QStringList& theOutputTypes,
 533                                 const bool theIsNeedGeometry )
 534   : TypeName( theTypeName ),
 535     PluginName( thePluginName ),
 536     ServerLibName( theServerLibName ),
 537     ClientLibName( theClientLibName ),
 538     Label( theLabel ),
 539     IconId( theIconId ),
 540     Dim( theDim ),
 541     IsAux( theIsAux ),
 542     NeededHypos( theNeededHypos ),
 543     OptionalHypos( theOptionalHypos ),
 544     InputTypes( theInputTypes ),
 545     OutputTypes( theOutputTypes ),
 546     IsNeedGeometry( theIsNeedGeometry )
 547 {
 548 }
 549
 550 HypothesesSet::HypothesesSet( const QString& theSetName )
 551   : HypoSetName( theSetName )
 552 {
 553 }
 554
 555 HypothesesSet::HypothesesSet( const QString&     theSetName,
 556                               const QStringList& theHypoList,
 557                               const QStringList& theAlgoList )
 558   : HypoSetName( theSetName ),
 559     HypoList( theHypoList ),
 560     AlgoList( theAlgoList )
 561 {
 562 }