src/GUI/NETGENPluginGUI_HypothesisCreator.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  NETGENPlugin GUI: GUI for plugged-in mesher NETGENPlugin
  24 //  File   : NETGENPluginGUI_HypothesisCreator.cxx
  25 //  Author : Michael Zorin
  26 //  Module : NETGENPlugin
  27 //
  28 #include "NETGENPluginGUI_HypothesisCreator.h"
  29
  30 #include <SMESHGUI_Utils.h>
  31 #include <SMESHGUI_HypothesesUtils.h>
  32 #include <SMESHGUI_SpinBox.h>
  33 #include <GeomSelectionTools.h>
  34
  35 #include CORBA_SERVER_HEADER(NETGENPlugin_Algorithm)
  36
  37 #include <LightApp_SelectionMgr.h>
  38 #include <SALOME_ListIO.hxx>
  39 #include <SUIT_FileDlg.h>
  40 #include <SUIT_ResourceMgr.h>
  41 #include <SUIT_Session.h>
  42 #include <SalomeApp_IntSpinBox.h>
  43 #include <SalomeApp_Tools.h>
  44
  45 #include <QComboBox>
  46 #include <QLabel>
  47 #include <QGroupBox>
  48 #include <QFrame>
  49 #include <QLayout>
  50 #include <QLineEdit>
  51 #include <QCheckBox>
  52 #include <QPixmap>
  53 #include <QTableWidget>
  54 #include <QHeaderView>
  55 #include <QPushButton>
  56
  57 enum Fineness {
  58   VeryCoarse,
  59   Coarse,
  60   Moderate,
  61   Fine,
  62   VeryFine,
  63   UserDefined
  64 };
  65
  66 enum {
  67   STD_TAB = 0,
  68   STL_TAB,
  69   LSZ_TAB,
  70   ADV_TAB
  71 };
  72
  73 enum {
  74   LSZ_ENTRY_COLUMN = 0,
  75   LSZ_NAME_COLUMN,
  76   LSZ_LOCALSIZE_COLUMN,
  77   LSZ_NB_COLUMNS
  78 };
  79
  80 enum {
  81   LSZ_BTNS = 0,
  82   LSZ_VERTEX_BTN,
  83   LSZ_EDGE_BTN,
  84   LSZ_FACE_BTN,
  85   LSZ_SOLID_BTN,
  86   LSZ_SEPARATOR2,
  87   LSZ_REMOVE_BTN,
  88   LSZ_FILE_LE = 9
  89 };
  90
  91 template<class SPINBOX, typename VALUETYPE>
  92 void setTextOrVar( SPINBOX* spin, VALUETYPE value, const QString& variable )
  93 {
  94   if ( spin )
  95   {
  96     if ( variable.isEmpty() )
  97       spin->setValue( value );
  98     else
  99       spin->setText( variable );
 100   }
 101 }
 102
 103 NETGENPluginGUI_HypothesisCreator::NETGENPluginGUI_HypothesisCreator( const QString& theHypType )
 104   : SMESHGUI_GenericHypothesisCreator( theHypType )
 105 {
 106   myGeomSelectionTools = NULL;
 107   myLocalSizeMap.clear();
 108   myIs2D   = ( theHypType.startsWith("NETGEN_Parameters_2D") ||
 109                theHypType == "NETGEN_RemesherParameters_2D");
 110   myIsONLY = ( theHypType == "NETGEN_Parameters_2D_ONLY" ||
 111                theHypType == "NETGEN_Parameters_3D" ||
 112                theHypType == "NETGEN_RemesherParameters_2D");
 113 }
 114
 115 NETGENPluginGUI_HypothesisCreator::~NETGENPluginGUI_HypothesisCreator()
 116 {
 117 }
 118
 119 bool NETGENPluginGUI_HypothesisCreator::checkParams(QString& msg) const
 120 {
 121   NetgenHypothesisData data_old, data_new;
 122   readParamsFromHypo( data_old );
 123   readParamsFromWidgets( data_new );
 124   bool res = storeParamsToHypo( data_new );
 125
 126   if ( !res ) //  -- issue 0021364: Dump of netgen parameters has duplicate lines
 127     storeParamsToHypo( data_old );
 128
 129   return res;
 130 }
 131
 132 QFrame* NETGENPluginGUI_HypothesisCreator::buildFrame()
 133 {
 134   const bool isRemesher = ( hypType() == "NETGEN_RemesherParameters_2D" );
 135
 136   QFrame* fr = new QFrame( 0 );
 137   fr->setObjectName( "myframe" );
 138   QVBoxLayout* lay = new QVBoxLayout( fr );
 139   lay->setMargin( 5 );
 140   lay->setSpacing( 0 );
 141
 142   QTabWidget* tab = new QTabWidget( fr );
 143   tab->setTabShape( QTabWidget::Rounded );
 144   tab->setTabPosition( QTabWidget::North );
 145   lay->addWidget( tab );
 146
 147   // ==============
 148   // Arguments TAB
 149   // ==============
 150
 151   QWidget* GroupC1 = new QWidget();
 152   tab->insertTab( STD_TAB, GroupC1, tr( "SMESH_ARGUMENTS" ) );
 153
 154   QGridLayout* aGroupLayout = new QGridLayout( GroupC1 );
 155   aGroupLayout->setMargin( 6 );
 156   aGroupLayout->setSpacing( 11 );
 157
 158   int row0 = 0;
 159   myName = 0;
 160   if ( isCreation() )
 161   {
 162     aGroupLayout->addWidget( new QLabel( tr( "SMESH_NAME" ), GroupC1 ), row0, 0 );
 163     myName = new QLineEdit( GroupC1 );
 164     myName->setMinimumWidth(160);
 165     aGroupLayout->addWidget( myName, row0, 1 );
 166     row0++;
 167   }
 168
 169   // Mesh size group
 170   // ----------------
 171   {
 172     QGroupBox* aSizeBox = new QGroupBox( tr("NETGEN_MESH_SIZE"), GroupC1 );
 173     aGroupLayout->addWidget( aSizeBox, row0, 0, 1, 2 );
 174     row0++;
 175
 176     QGridLayout* aSizeLayout = new QGridLayout( aSizeBox );
 177     aSizeLayout->setSpacing( 6 );
 178     aSizeLayout->setMargin( 11 );
 179     int row = 0;
 180
 181     aSizeLayout->addWidget( new QLabel( tr( "NETGEN_MAX_SIZE" ), aSizeBox ), row, 0 );
 182     myMaxSize = new SMESHGUI_SpinBox( aSizeBox );
 183     myMaxSize->RangeStepAndValidator( 1e-07, 1e+06, 10., "length_precision" );
 184     aSizeLayout->addWidget( myMaxSize, row, 1 );
 185     row++;
 186
 187     aSizeLayout->addWidget( new QLabel( tr( "NETGEN_MIN_SIZE" ), aSizeBox ), row, 0 );
 188     myMinSize = new SMESHGUI_SpinBox( aSizeBox );
 189     myMinSize->RangeStepAndValidator( 0.0, 1e+06, 10., "length_precision" );
 190     aSizeLayout->addWidget( myMinSize, row, 1 );
 191     row++;
 192
 193     aSizeLayout->addWidget( new QLabel( tr( "NETGEN_FINENESS" ), aSizeBox ), row, 0 );
 194     myFineness = new QComboBox( aSizeBox );
 195     QStringList types;
 196     types << tr( "NETGEN_VERYCOARSE" ) << tr( "NETGEN_COARSE" )   << tr( "NETGEN_MODERATE" ) <<
 197       tr( "NETGEN_FINE" )       << tr( "NETGEN_VERYFINE" ) << tr( "NETGEN_CUSTOM" );
 198     myFineness->addItems( types );
 199     aSizeLayout->addWidget( myFineness, row, 1 );
 200     connect( myFineness, SIGNAL( activated( int ) ), this, SLOT( onFinenessChanged() ) );
 201     row++;
 202
 203     aSizeLayout->addWidget( new QLabel( tr( "NETGEN_GROWTH_RATE" ), aSizeBox ), row, 0 );
 204     myGrowthRate = new SMESHGUI_SpinBox( aSizeBox );
 205     myGrowthRate->RangeStepAndValidator( .0001, 10., .1, "parametric_precision" );
 206     aSizeLayout->addWidget( myGrowthRate, row, 1 );
 207     row++;
 208
 209     myNbSegPerEdge = 0;
 210     myNbSegPerRadius = 0;
 211     if ( !myIsONLY )
 212     {
 213       const double VALUE_MAX = 1.0e+6;
 214
 215       aSizeLayout->addWidget( new QLabel( tr( "NETGEN_SEG_PER_EDGE" ), aSizeBox ), row, 0 );
 216       myNbSegPerEdge = new SMESHGUI_SpinBox( aSizeBox );
 217       myNbSegPerEdge->RangeStepAndValidator( .2, VALUE_MAX, .1, "parametric_precision" );
 218       aSizeLayout->addWidget( myNbSegPerEdge, row, 1 );
 219       row++;
 220
 221       aSizeLayout->addWidget( new QLabel( tr( "NETGEN_SEG_PER_RADIUS" ), aSizeBox ), row, 0 );
 222       myNbSegPerRadius = new SMESHGUI_SpinBox( aSizeBox );
 223       myNbSegPerRadius->RangeStepAndValidator( .2, VALUE_MAX, .1, "parametric_precision" );
 224       aSizeLayout->addWidget( myNbSegPerRadius, row, 1 );
 225       row++;
 226     }
 227
 228     myChordalErrorEnabled = 0;
 229     myChordalError = 0;
 230     if (( myIs2D && !isRemesher ) || !myIsONLY )
 231     {
 232       myChordalErrorEnabled = new QCheckBox( tr( "NETGEN_CHORDAL_ERROR" ), aSizeBox );
 233       aSizeLayout->addWidget( myChordalErrorEnabled, row, 0 );
 234       myChordalError = new SMESHGUI_SpinBox( aSizeBox );
 235       myChordalError->RangeStepAndValidator( COORD_MIN, COORD_MAX, .1, "length_precision" );
 236       aSizeLayout->addWidget( myChordalError, row, 1 );
 237       connect( myChordalErrorEnabled, SIGNAL( stateChanged(int)), SLOT( onChordalErrorEnabled()));
 238       row++;
 239     }
 240
 241     mySurfaceCurvature = 0;
 242     if (( myIs2D && !isRemesher ) || !myIsONLY )
 243     {
 244       mySurfaceCurvature = new QCheckBox( tr( "NETGEN_SURFACE_CURVATURE" ), aSizeBox );
 245       aSizeLayout->addWidget( mySurfaceCurvature, row, 0, 1, 2 );
 246       connect( mySurfaceCurvature, SIGNAL( stateChanged( int ) ), this, SLOT( onSurfaceCurvatureChanged() ) );
 247       row++;
 248     }
 249   } // end Mesh Size box
 250
 251   myAllowQuadrangles = 0;
 252   if ( myIs2D || !myIsONLY ) // disable only for NETGEN 3D
 253   {
 254     myAllowQuadrangles = new QCheckBox( tr( "NETGEN_ALLOW_QUADRANGLES" ), GroupC1 );
 255     aGroupLayout->addWidget( myAllowQuadrangles, row0, 0, 1, 2 );
 256     row0++;
 257   }
 258
 259   mySecondOrder = 0;
 260   if ( !myIsONLY )
 261   {
 262     mySecondOrder = new QCheckBox( tr( "NETGEN_SECOND_ORDER" ), GroupC1 );
 263     aGroupLayout->addWidget( mySecondOrder, row0, 0, 1, 2 );
 264     row0++;
 265   }
 266
 267   myOptimize = 0;
 268   // if ( !isRemesher ) ???
 269   {
 270     myOptimize = new QCheckBox( tr( "NETGEN_OPTIMIZE" ), GroupC1 );
 271     aGroupLayout->addWidget( myOptimize, row0, 0, 1, 2 );
 272     row0++;
 273   }
 274
 275   myKeepExistingEdges = myMakeGroupsOfSurfaces = 0;
 276   if ( isRemesher )
 277   {
 278     myKeepExistingEdges = new QCheckBox( tr( "NETGEN_KEEP_EXISTING_EDGES" ), GroupC1 );
 279     aGroupLayout->addWidget( myKeepExistingEdges, row0, 0, 1, 2 );
 280     row0++;
 281
 282     myMakeGroupsOfSurfaces = new QCheckBox( tr( "NETGEN_MAKE_SURFACE_GROUPS" ), GroupC1 );
 283     aGroupLayout->addWidget( myMakeGroupsOfSurfaces, row0, 0, 1, 2 );
 284     row0++;
 285   }
 286
 287   aGroupLayout->setRowStretch( row0, 1 );
 288
 289   // ========
 290   // STL TAB
 291   // ========
 292
 293   QWidget* stlGroup = new QWidget();
 294   QVBoxLayout* stlLay = new QVBoxLayout( stlGroup );
 295   stlLay->setMargin( 5 );
 296   stlLay->setSpacing( 10 );
 297
 298   // Charts group
 299   {
 300     QGroupBox* chaGroup = new QGroupBox( tr("NETGEN_STL_CHARTS"), stlGroup );
 301     stlLay->addWidget( chaGroup );
 302
 303     QGridLayout* chaLayout = new QGridLayout( chaGroup );
 304     chaLayout->setMargin( 6 );
 305     chaLayout->setSpacing( 6 );
 306
 307     int row = 0;
 308     chaLayout->addWidget( new QLabel( tr( "NETGEN_RIDGE_ANGLE" ), chaGroup ), row, 0 );
 309     myRidgeAngle = new SMESHGUI_SpinBox( chaGroup );
 310     myRidgeAngle->RangeStepAndValidator( 0, 90, 10, "angle_precision" );
 311     chaLayout->addWidget( myRidgeAngle, row, 1 );
 312     row++;
 313
 314     chaLayout->addWidget( new QLabel( tr( "NETGEN_EDGE_CORNER_ANGLE" ), chaGroup ), row, 0 );
 315     myEdgeCornerAngle = new SMESHGUI_SpinBox( chaGroup );
 316     myEdgeCornerAngle->RangeStepAndValidator( 0., 180., 20., "angle_precision" );
 317     chaLayout->addWidget( myEdgeCornerAngle, row, 1 );
 318     row++;
 319
 320     chaLayout->addWidget( new QLabel( tr( "NETGEN_CHART_ANGLE" ), chaGroup ), row, 0 );
 321     myChartAngle = new SMESHGUI_SpinBox( chaGroup );
 322     myChartAngle->RangeStepAndValidator( 0., 180., 20., "angle_precision" );
 323     chaLayout->addWidget( myChartAngle, row, 1 );
 324     row++;
 325
 326     chaLayout->addWidget( new QLabel( tr( "NETGEN_OUTER_CHART_ANGLE" ), chaGroup ), row, 0 );
 327     myOuterChartAngle = new SMESHGUI_SpinBox( chaGroup );
 328     myOuterChartAngle->RangeStepAndValidator( 0., 180., 20., "angle_precision" );
 329     chaLayout->addWidget( myOuterChartAngle, row, 1 );
 330     row++;
 331   }
 332   // STL size group
 333   {
 334     QGroupBox* sizeGroup = new QGroupBox( tr("NETGEN_STL_SIZE"), stlGroup );
 335     stlLay->addWidget( sizeGroup );
 336
 337     QGridLayout* sizeLayout = new QGridLayout( sizeGroup );
 338     sizeLayout->setMargin( 6 );
 339     sizeLayout->setSpacing( 6 );
 340
 341     int row = 0;
 342     myRestHChartDistEnable = new QCheckBox( tr("NETGEN_RESTH_CHART_DIST"), sizeGroup );
 343     sizeLayout->addWidget( myRestHChartDistEnable, row, 0 );
 344     myRestHChartDistFactor = new SMESHGUI_SpinBox( sizeGroup );
 345     myRestHChartDistFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
 346     sizeLayout->addWidget( myRestHChartDistFactor, row, 1 );
 347     row++;
 348
 349     myRestHLineLengthEnable = new QCheckBox( tr("NETGEN_RESTH_LINE_LENGTH"), sizeGroup );
 350     sizeLayout->addWidget( myRestHLineLengthEnable, row, 0 );
 351     myRestHLineLengthFactor = new SMESHGUI_SpinBox( sizeGroup );
 352     myRestHLineLengthFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
 353     sizeLayout->addWidget( myRestHLineLengthFactor, row, 1 );
 354     row++;
 355
 356     myRestHCloseEdgeEnable = new QCheckBox( tr("NETGEN_RESTH_CLOSE_EDGE"), sizeGroup );
 357     sizeLayout->addWidget( myRestHCloseEdgeEnable, row, 0 );
 358     myRestHCloseEdgeFactor = new SMESHGUI_SpinBox( sizeGroup );
 359     myRestHCloseEdgeFactor->RangeStepAndValidator( 0.2, 8., 0.1, "length_precision" );
 360     sizeLayout->addWidget( myRestHCloseEdgeFactor, row, 1 );
 361     row++;
 362
 363     myRestHSurfCurvEnable = new QCheckBox( tr("NETGEN_RESTH_SURF_CURV"), sizeGroup );
 364     sizeLayout->addWidget( myRestHSurfCurvEnable, row, 0 );
 365     myRestHSurfCurvFactor = new SMESHGUI_SpinBox( sizeGroup );
 366     myRestHSurfCurvFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
 367     sizeLayout->addWidget( myRestHSurfCurvFactor, row, 1 );
 368     row++;
 369
 370     myRestHEdgeAngleEnable = new QCheckBox( tr("NETGEN_RESTH_EDGE_ANGLE"), sizeGroup );
 371     sizeLayout->addWidget( myRestHEdgeAngleEnable, row, 0 );
 372     myRestHEdgeAngleFactor = new SMESHGUI_SpinBox( sizeGroup );
 373     myRestHEdgeAngleFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
 374     sizeLayout->addWidget( myRestHEdgeAngleFactor, row, 1 );
 375     row++;
 376
 377     myRestHSurfMeshCurvEnable = new QCheckBox( tr("NETGEN_RESTH_SURF_MESH_CURV"), sizeGroup );
 378     sizeLayout->addWidget( myRestHSurfMeshCurvEnable, row, 0 );
 379     myRestHSurfMeshCurvFactor = new SMESHGUI_SpinBox( sizeGroup );
 380     myRestHSurfMeshCurvFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
 381     sizeLayout->addWidget( myRestHSurfMeshCurvFactor, row, 1 );
 382     row++;
 383   }
 384   if ( isRemesher )
 385   {
 386     tab->insertTab( STL_TAB, stlGroup, tr( "NETGEN_STL" ));
 387     connect( myRestHChartDistEnable   , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
 388     connect( myRestHLineLengthEnable  , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
 389     connect( myRestHCloseEdgeEnable   , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
 390     connect( myRestHSurfCurvEnable    , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
 391     connect( myRestHEdgeAngleEnable   , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
 392     connect( myRestHSurfMeshCurvEnable, SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
 393   }
 394   else
 395   {
 396     delete stlGroup;
 397     myRidgeAngle = 0;
 398   }
 399
 400   // ===============
 401   // Local Size TAB
 402   // ===============
 403
 404   myLocalSizeTable = 0;
 405   //if ( !myIsONLY )
 406   {
 407     QWidget* localSizeGroup = new QWidget();
 408     QGridLayout* localSizeLayout = new QGridLayout(localSizeGroup);
 409
 410     myLocalSizeTable = new QTableWidget(0, LSZ_NB_COLUMNS, localSizeGroup);
 411     localSizeLayout->addWidget(myLocalSizeTable, 1, 0, 8, 2);
 412     QStringList localSizeHeaders;
 413     localSizeHeaders << tr( "LSZ_ENTRY_COLUMN" )<< tr( "LSZ_NAME_COLUMN" ) << tr( "LSZ_LOCALSIZE_COLUMN" );
 414     myLocalSizeTable->setHorizontalHeaderLabels(localSizeHeaders);
 415     myLocalSizeTable->horizontalHeader()->hideSection(LSZ_ENTRY_COLUMN);
 416 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
 417     myLocalSizeTable->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
 418 #else
 419     myLocalSizeTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
 420 #endif
 421     myLocalSizeTable->resizeColumnToContents(LSZ_NAME_COLUMN);
 422     myLocalSizeTable->resizeColumnToContents(LSZ_LOCALSIZE_COLUMN);
 423     myLocalSizeTable->setAlternatingRowColors(true);
 424     myLocalSizeTable->verticalHeader()->hide();
 425
 426     QPushButton* addVertexButton = new QPushButton(tr("NETGEN_LSZ_VERTEX"), localSizeGroup);
 427     localSizeLayout->addWidget(addVertexButton, LSZ_VERTEX_BTN, 2, 1, 1);
 428     QPushButton* addEdgeButton = new QPushButton(tr("NETGEN_LSZ_EDGE"), localSizeGroup);
 429     localSizeLayout->addWidget(addEdgeButton, LSZ_EDGE_BTN, 2, 1, 1);
 430     QPushButton* addFaceButton = new QPushButton(tr("NETGEN_LSZ_FACE"), localSizeGroup);
 431     localSizeLayout->addWidget(addFaceButton, LSZ_FACE_BTN, 2, 1, 1);
 432     QPushButton* addSolidButton = new QPushButton(tr("NETGEN_LSZ_SOLID"), localSizeGroup);
 433     localSizeLayout->addWidget(addSolidButton, LSZ_SOLID_BTN, 2, 1, 1);
 434
 435     QFrame *line2 = new QFrame(localSizeGroup);
 436     line2->setFrameShape(QFrame::HLine);
 437     line2->setFrameShadow(QFrame::Sunken);
 438     localSizeLayout->addWidget(line2, LSZ_SEPARATOR2, 2, 1, 1);
 439
 440     QPushButton* removeButton = new QPushButton(tr("NETGEN_LSZ_REMOVE"), localSizeGroup);
 441     localSizeLayout->addWidget(removeButton, LSZ_REMOVE_BTN, 2, 1, 1);
 442
 443     QPushButton* fileBtn = new QPushButton(tr("NETGEN_LSZ_FILE"), localSizeGroup);
 444     myMeshSizeFile = new QLineEdit(localSizeGroup);
 445     myMeshSizeFile->setReadOnly( true );
 446     localSizeLayout->addWidget( fileBtn, LSZ_FILE_LE, 0, 1, 1);
 447     localSizeLayout->addWidget( myMeshSizeFile, LSZ_FILE_LE, 1, 1, 2);
 448
 449     connect( addVertexButton, SIGNAL(clicked()), this, SLOT(onAddLocalSizeOnVertex()));
 450     connect( addEdgeButton, SIGNAL(clicked()), this, SLOT(onAddLocalSizeOnEdge()));
 451     connect( addFaceButton, SIGNAL(clicked()), this, SLOT(onAddLocalSizeOnFace()));
 452     connect( addSolidButton, SIGNAL(clicked()), this, SLOT(onAddLocalSizeOnSolid()));
 453     connect( removeButton, SIGNAL(clicked()), this, SLOT(onRemoveLocalSizeOnShape()));
 454     connect( myLocalSizeTable, SIGNAL(cellChanged(int, int)), this, SLOT(onSetLocalSize(int, int)));
 455     connect( fileBtn, SIGNAL(clicked()), this, SLOT(onSetSizeFile()));
 456
 457     tab->insertTab(LSZ_TAB, localSizeGroup, tr("NETGEN_LOCAL_SIZE"));
 458   }
 459
 460   // =============
 461   // Advanced TAB
 462   // =============
 463
 464   QWidget* advGroup = new QWidget();
 465   tab->insertTab( ADV_TAB, advGroup, tr( "SMESH_ADVANCED" ));
 466   QVBoxLayout* advLay = new QVBoxLayout( advGroup );
 467   advLay->setSpacing( 6 );
 468   advLay->setMargin( 5 );
 469
 470   // Optimizer group
 471   // ----------------
 472   {
 473     QGroupBox* optBox = new QGroupBox( tr("NETGEN_OPTIMIZER"), advGroup );
 474     advLay->addWidget( optBox );
 475
 476     QGridLayout* optLayout = new QGridLayout( optBox );
 477     optLayout->setMargin( 6 );
 478     optLayout->setSpacing( 6 );
 479
 480     int row = 0;
 481     optLayout->addWidget( new QLabel( tr( "NETGEN_ELEM_SIZE_WEIGHT" ), optBox ), row, 0 );
 482     myElemSizeWeight = new SMESHGUI_SpinBox( optBox );
 483     myElemSizeWeight->RangeStepAndValidator( 0., 1., 0.1, "parametric_precision" );
 484     optLayout->addWidget( myElemSizeWeight, row, 1 );
 485     row++;
 486
 487     myNbSurfOptSteps = 0;
 488     if ( myIs2D || !myIsONLY )
 489     {
 490       optLayout->addWidget( new QLabel( tr( "NETGEN_NB_SURF_OPT_STEPS" ), optBox ), row, 0 );
 491       myNbSurfOptSteps = new SalomeApp_IntSpinBox( optBox );
 492       myNbSurfOptSteps->setMinimum( 0 );
 493       myNbSurfOptSteps->setMaximum( 99 );
 494       optLayout->addWidget( myNbSurfOptSteps, row, 1 );
 495       row++;
 496     }
 497
 498     myNbVolOptSteps = 0;
 499     if ( !myIs2D )
 500     {
 501       optLayout->addWidget( new QLabel( tr( "NETGEN_NB_VOL_OPT_STEPS" ), optBox ), row, 0 );
 502       myNbVolOptSteps = new SalomeApp_IntSpinBox( optBox );
 503       myNbVolOptSteps->setMinimum( 0 );
 504       myNbVolOptSteps->setMaximum( 99 );
 505       optLayout->addWidget( myNbVolOptSteps, row, 1 );
 506     }
 507   }
 508   // Insider group
 509   {
 510     QGroupBox* insGroup = new QGroupBox( tr("NETGEN_INSIDER"), advGroup );
 511     advLay->addWidget( insGroup );
 512
 513     QGridLayout* insLayout = new QGridLayout( insGroup );
 514     insLayout->setMargin( 6 );
 515     insLayout->setSpacing( 6 );
 516
 517     int row = 0;
 518     insLayout->addWidget( new QLabel( tr( "NETGEN_WORST_ELEM_MEASURE" ), insGroup ), row, 0 );
 519     myWorstElemMeasure = new SalomeApp_IntSpinBox( insGroup );
 520     myWorstElemMeasure->setMinimum( 1 );
 521     myWorstElemMeasure->setMaximum( 10 );
 522     insLayout->addWidget( myWorstElemMeasure, row, 1, 1, 2 );
 523     row++;
 524
 525     myUseDelauney = new QCheckBox( tr( "NETGEN_USE_DELAUNEY" ), insGroup );
 526     insLayout->addWidget( myUseDelauney, row, 0, 1, 2 );
 527     row++;
 528
 529     myCheckOverlapping = new QCheckBox( tr( "NETGEN_CHECK_OVERLAPPING" ), insGroup );
 530     insLayout->addWidget( myCheckOverlapping, row, 0, 1, 2 );
 531     row++;
 532
 533     myCheckChartBoundary = new QCheckBox( tr( "NETGEN_CHECK_CHART_BOUNDARY" ), insGroup );
 534     insLayout->addWidget( myCheckChartBoundary, row, 0, 1, 2 );
 535     row++;
 536
 537     myFuseEdges = 0;
 538     if ( !myIsONLY && !isRemesher )
 539     {
 540       myFuseEdges = new QCheckBox( tr( "NETGEN_FUSE_EDGES" ), insGroup );
 541       insLayout->addWidget( myFuseEdges, row, 0, 1, 2 );
 542       row++;
 543     }
 544     insLayout->setRowStretch( row, 1 );
 545   }
 546
 547   return fr;
 548 }
 549
 550 void NETGENPluginGUI_HypothesisCreator::retrieveParams() const
 551 {
 552   NetgenHypothesisData data;
 553   readParamsFromHypo( data );
 554
 555   if( myName )
 556     myName->setText( data.myName );
 557
 558   setTextOrVar( myMaxSize, data.myMaxSize, data.myMaxSizeVar );
 559   setTextOrVar( myMinSize, data.myMinSize, data.myMinSizeVar );
 560   if ( mySecondOrder )
 561     mySecondOrder->setChecked( data.mySecondOrder );
 562   if ( myOptimize )
 563     myOptimize->setChecked( data.myOptimize );
 564   myFineness->setCurrentIndex( data.myFineness );
 565   setTextOrVar( myGrowthRate, data.myGrowthRate, data.myGrowthRateVar );
 566   setTextOrVar( myNbSegPerEdge, data.myNbSegPerEdge, data.myNbSegPerEdgeVar );
 567   setTextOrVar( myNbSegPerRadius, data.myNbSegPerRadius, data.myNbSegPerRadiusVar );
 568
 569   if ( myChordalError )
 570   {
 571     myChordalErrorEnabled->setChecked( data.myChordalErrorEnabled && data.myChordalError > 0 );
 572     setTextOrVar( myChordalError, data.myChordalError, data.myChordalErrorVar );
 573     myChordalError->setEnabled( myChordalErrorEnabled->isChecked() );
 574   }
 575   if (myAllowQuadrangles)
 576     myAllowQuadrangles->setChecked( data.myAllowQuadrangles );
 577   if (mySurfaceCurvature)
 578     mySurfaceCurvature->setChecked( data.mySurfaceCurvature );
 579
 580   if ( myKeepExistingEdges )
 581   {
 582     myKeepExistingEdges->setChecked( data.myKeepExistingEdges );
 583     myMakeGroupsOfSurfaces->setChecked( data.myMakeGroupsOfSurfaces );
 584   }
 585
 586   setTextOrVar( myElemSizeWeight, data.myElemSizeWeight, data.myElemSizeWeightVar );
 587   setTextOrVar( myNbSurfOptSteps, data.myNbSurfOptSteps, data.myNbSurfOptStepsVar );
 588   setTextOrVar( myNbVolOptSteps,  data.myNbVolOptSteps,  data.myNbVolOptStepsVar );
 589
 590   if (myFuseEdges)
 591     myFuseEdges->setChecked( data.myFuseEdges );
 592   setTextOrVar( myWorstElemMeasure, data.myWorstElemMeasure, data.myWorstElemMeasureVar );
 593   myUseDelauney->setChecked( data.myUseDelauney );
 594   myCheckOverlapping->setChecked( data.myCheckOverlapping );
 595   myCheckChartBoundary->setChecked( data.myCheckChartBoundary );
 596
 597   if ( myRidgeAngle )
 598   {
 599     setTextOrVar( myRidgeAngle, data.myRidgeAngle, data.myRidgeAngleVar );
 600     setTextOrVar( myEdgeCornerAngle, data.myEdgeCornerAngle, data.myEdgeCornerAngleVar );
 601     setTextOrVar( myChartAngle, data.myChartAngle, data.myChartAngleVar );
 602     setTextOrVar( myOuterChartAngle, data.myOuterChartAngle, data.myOuterChartAngleVar );
 603     setTextOrVar( myRestHChartDistFactor, data.myRestHChartDistFactor,
 604                   data.myRestHChartDistFactorVar );
 605     setTextOrVar( myRestHLineLengthFactor, data.myRestHLineLengthFactor,
 606                   data.myRestHLineLengthFactorVar );
 607     setTextOrVar( myRestHCloseEdgeFactor, data.myRestHCloseEdgeFactor,
 608                   data.myRestHCloseEdgeFactorVar );
 609     setTextOrVar( myRestHSurfCurvFactor, data.myRestHSurfCurvFactor,
 610                   data.myRestHSurfCurvFactorVar );
 611     setTextOrVar( myRestHEdgeAngleFactor, data.myRestHEdgeAngleFactor,
 612                   data.myRestHEdgeAngleFactorVar );
 613     setTextOrVar( myRestHSurfMeshCurvFactor, data.myRestHSurfMeshCurvFactor,
 614                   data.myRestHSurfMeshCurvFactorVar );
 615
 616     myRestHChartDistEnable->setChecked( data.myRestHChartDistEnable );
 617     myRestHLineLengthEnable->setChecked( data.myRestHLineLengthEnable );
 618     myRestHCloseEdgeEnable->setChecked( data.myRestHCloseEdgeEnable );
 619     myRestHSurfCurvEnable->setChecked( data.myRestHSurfCurvEnable );
 620     myRestHEdgeAngleEnable->setChecked( data.myRestHEdgeAngleEnable );
 621     myRestHSurfMeshCurvEnable->setChecked( data.myRestHSurfMeshCurvEnable );
 622   }
 623
 624   // update widgets
 625   ((NETGENPluginGUI_HypothesisCreator*) this )-> onSurfaceCurvatureChanged();
 626
 627   if ( myLocalSizeTable )
 628   {
 629     NETGENPluginGUI_HypothesisCreator* that = (NETGENPluginGUI_HypothesisCreator*)this;
 630     QMapIterator<QString, QString> i(myLocalSizeMap);
 631     GeomSelectionTools* geomSelectionTools = that->getGeomSelectionTools();
 632     while (i.hasNext()) {
 633       i.next();
 634       const QString entry = i.key();
 635       std::string shapeName = geomSelectionTools->getNameFromEntry(entry.toStdString());
 636       const QString localSize = i.value();
 637       int row = myLocalSizeTable->rowCount();
 638       myLocalSizeTable->setRowCount(row+1);
 639       myLocalSizeTable->setItem(row, LSZ_ENTRY_COLUMN, new QTableWidgetItem(entry));
 640       myLocalSizeTable->item(row, LSZ_ENTRY_COLUMN)->setFlags(0);
 641       myLocalSizeTable->setItem(row, LSZ_NAME_COLUMN, new QTableWidgetItem(QString::fromStdString(shapeName)));
 642       myLocalSizeTable->item(row, LSZ_NAME_COLUMN)->setFlags(0);
 643       myLocalSizeTable->setItem(row, LSZ_LOCALSIZE_COLUMN, new QTableWidgetItem(localSize));
 644       myLocalSizeTable->item(row, LSZ_LOCALSIZE_COLUMN)->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled);
 645     }
 646     myLocalSizeTable->resizeColumnToContents(LSZ_NAME_COLUMN);
 647     myLocalSizeTable->resizeColumnToContents(LSZ_LOCALSIZE_COLUMN);
 648
 649     myMeshSizeFile->setText( data.myMeshSizeFile );
 650   }
 651 }
 652
 653 QString NETGENPluginGUI_HypothesisCreator::storeParams() const
 654 {
 655   NetgenHypothesisData data;
 656   readParamsFromWidgets( data );
 657   storeParamsToHypo( data );
 658
 659   return QString();
 660 }
 661
 662 bool NETGENPluginGUI_HypothesisCreator::readParamsFromHypo( NetgenHypothesisData& h_data ) const
 663 {
 664   NETGENPlugin::NETGENPlugin_Hypothesis_var h =
 665     NETGENPlugin::NETGENPlugin_Hypothesis::_narrow( initParamsHypothesis() );
 666
 667   h_data.myName = isCreation() ? hypName() : "";
 668
 669   h_data.myMaxSize             = h->GetMaxSize();
 670   h_data.myMaxSizeVar          = getVariableName("SetMaxSize");
 671   h_data.myMinSize             = h->GetMinSize();
 672   h_data.myMinSizeVar          = getVariableName("SetMinSize");
 673   h_data.mySecondOrder         = h->GetSecondOrder();
 674   h_data.myOptimize            = h->GetOptimize();
 675
 676   h_data.myFineness            = (int) h->GetFineness();
 677   h_data.myGrowthRate          = h->GetGrowthRate();
 678   h_data.myGrowthRateVar       = getVariableName("SetGrowthRate");
 679   h_data.myNbSegPerEdge        = h->GetNbSegPerEdge();
 680   h_data.myNbSegPerEdgeVar     = getVariableName("SetNbSegPerEdge");
 681   h_data.myNbSegPerRadius      = h->GetNbSegPerRadius();
 682   h_data.myNbSegPerRadiusVar   = getVariableName("SetNbSegPerRadius");
 683   h_data.myChordalError        = h->GetChordalError();
 684   h_data.myChordalErrorVar     = getVariableName("SetChordalError");
 685   h_data.myChordalErrorEnabled = h->GetChordalErrorEnabled();
 686   h_data.mySurfaceCurvature    = h->GetUseSurfaceCurvature();
 687
 688   h_data.myElemSizeWeight      = h->GetElemSizeWeight    ();
 689   h_data.myElemSizeWeightVar   = getVariableName("SetElemSizeWeight");
 690   h_data.myNbSurfOptSteps      = h->GetNbSurfOptSteps    ();
 691   h_data.myNbSurfOptStepsVar   = getVariableName("SetNbSurfOptSteps");
 692   h_data.myNbVolOptSteps       = h->GetNbVolOptSteps     ();
 693   h_data.myNbVolOptStepsVar    = getVariableName("SetNbVolOptSteps");
 694   h_data.myFuseEdges           = h->GetFuseEdges();
 695   h_data.myWorstElemMeasure    = h->GetWorstElemMeasure  ();
 696   h_data.myWorstElemMeasureVar = getVariableName("SetWorstElemMeasure");
 697   h_data.myUseDelauney         = h->GetUseDelauney       ();
 698   h_data.myCheckOverlapping    = h->GetCheckOverlapping  ();
 699   h_data.myCheckChartBoundary  = h->GetCheckChartBoundary();
 700
 701   h_data.myMeshSizeFile        = h->GetMeshSizeFile();
 702
 703   //if ( myIs2D )
 704   {
 705     // NETGENPlugin::NETGENPlugin_Hypothesis_var h =
 706     //   NETGENPlugin::NETGENPlugin_Hypothesis::_narrow( initParamsHypothesis() );
 707
 708     if ( !h->_is_nil() )
 709       h_data.myAllowQuadrangles = h->GetQuadAllowed();
 710   }
 711   if ( myIs2D )
 712   {
 713     NETGENPlugin::NETGENPlugin_RemesherHypothesis_2D_var rh =
 714       NETGENPlugin::NETGENPlugin_RemesherHypothesis_2D::_narrow( h );
 715     if ( !rh->_is_nil() )
 716     {
 717       h_data.myRidgeAngle                 = rh->GetRidgeAngle();
 718       h_data.myRidgeAngleVar              = getVariableName("SetRidgeAngle");
 719       h_data.myEdgeCornerAngle            = rh->GetEdgeCornerAngle        ();
 720       h_data.myEdgeCornerAngleVar         = getVariableName("SetEdgeCornerAngle");
 721       h_data.myChartAngle                 = rh->GetChartAngle             ();
 722       h_data.myChartAngleVar              = getVariableName("SetChartAngle");
 723       h_data.myOuterChartAngle            = rh->GetOuterChartAngle        ();
 724       h_data.myOuterChartAngleVar         = getVariableName("SetOuterChartAngle");
 725       h_data.myRestHChartDistFactor       = rh->GetRestHChartDistFactor   ();
 726       h_data.myRestHChartDistFactorVar    = getVariableName("SetRestHChartDistFactor");
 727       h_data.myRestHLineLengthFactor      = rh->GetRestHLineLengthFactor  ();
 728       h_data.myRestHLineLengthFactorVar   = getVariableName("SetRestHLineLengthFactor");
 729       h_data.myRestHCloseEdgeFactor       = rh->GetRestHCloseEdgeFactor   ();
 730       h_data.myRestHCloseEdgeFactorVar    = getVariableName("SetRestHCloseEdgeFactor");
 731       h_data.myRestHSurfCurvFactor        = rh->GetRestHSurfCurvFactor    ();
 732       h_data.myRestHSurfCurvFactorVar     = getVariableName("SetRestHSurfCurvFactor");
 733       h_data.myRestHEdgeAngleFactor       = rh->GetRestHEdgeAngleFactor   ();
 734       h_data.myRestHEdgeAngleFactorVar    = getVariableName("SetRestHEdgeAngleFactor");
 735       h_data.myRestHSurfMeshCurvFactor    = rh->GetRestHSurfMeshCurvFactor();
 736       h_data.myRestHSurfMeshCurvFactorVar = getVariableName("SetRestHSurfMeshCurvFactor");
 737       h_data.myRestHChartDistEnable       = rh->GetRestHChartDistEnable   ();
 738       h_data.myRestHLineLengthEnable      = rh->GetRestHLineLengthEnable  ();
 739       h_data.myRestHCloseEdgeEnable       = rh->GetRestHCloseEdgeEnable   ();
 740       h_data.myRestHSurfCurvEnable        = rh->GetRestHSurfCurvEnable    ();
 741       h_data.myRestHEdgeAngleEnable       = rh->GetRestHEdgeAngleEnable   ();
 742       h_data.myRestHSurfMeshCurvEnable    = rh->GetRestHSurfMeshCurvEnable();
 743       h_data.myKeepExistingEdges          = rh->GetKeepExistingEdges      ();
 744       h_data.myMakeGroupsOfSurfaces       = rh->GetMakeGroupsOfSurfaces   ();
 745     }
 746   }
 747
 748   NETGENPluginGUI_HypothesisCreator*  that = (NETGENPluginGUI_HypothesisCreator*)this;
 749   NETGENPlugin::string_array_var myEntries = h->GetLocalSizeEntries();
 750   for ( size_t i = 0; i < myEntries->length(); i++ )
 751   {
 752     QString entry = myEntries[i].in();
 753     if (myLocalSizeMap.contains(entry) &&
 754         myLocalSizeMap[entry] == "__TO_DELETE__")
 755       continue;
 756     double val = h->GetLocalSizeOnEntry( myEntries[i] );
 757     std::ostringstream tmp;
 758     tmp << val;
 759     that->myLocalSizeMap[entry] = tmp.str().c_str();
 760   }
 761
 762   return true;
 763 }
 764
 765 bool NETGENPluginGUI_HypothesisCreator::storeParamsToHypo( const NetgenHypothesisData& h_data ) const
 766 {
 767   NETGENPlugin::NETGENPlugin_Hypothesis_var h =
 768     NETGENPlugin::NETGENPlugin_Hypothesis::_narrow( hypothesis() );
 769
 770   bool ok = true;
 771   try
 772   {
 773     if ( isCreation() )
 774       SMESH::SetName( SMESH::FindSObject( h ), h_data.myName.toLatin1().data() );
 775     h->SetVarParameter( h_data.myMaxSizeVar.toLatin1().constData(), "SetMaxSize");
 776     h->SetMaxSize     ( h_data.myMaxSize );
 777     h->SetVarParameter( h_data.myMinSizeVar.toLatin1().constData(), "SetMinSize");
 778     h->SetMinSize     ( h_data.myMinSize );
 779     if ( mySecondOrder )
 780       h->SetSecondOrder ( h_data.mySecondOrder );
 781     if ( myOptimize )
 782       h->SetOptimize    ( h_data.myOptimize );
 783     h->SetFineness    ( h_data.myFineness );
 784
 785     if ( h_data.myFineness == UserDefined )
 786     {
 787       h->SetVarParameter  ( h_data.myGrowthRateVar.toLatin1().constData(), "SetGrowthRate");
 788       h->SetGrowthRate    ( h_data.myGrowthRate );
 789       if ( myNbSegPerEdge )
 790       {
 791         h->SetVarParameter  ( h_data.myNbSegPerEdgeVar.toLatin1().constData(), "SetNbSegPerEdge");
 792         h->SetNbSegPerEdge  ( h_data.myNbSegPerEdge );
 793       }
 794       if ( myNbSegPerRadius )
 795       {
 796         h->SetVarParameter  ( h_data.myNbSegPerRadiusVar.toLatin1().constData(), "SetNbSegPerRadius");
 797         h->SetNbSegPerRadius( h_data.myNbSegPerRadius );
 798       }
 799     }
 800     if ( myChordalError )
 801     {
 802       h->SetVarParameter       ( h_data.myChordalErrorVar.toLatin1().constData(), "SetChordalError");
 803       h->SetChordalError       ( h_data.myChordalError );
 804       h->SetChordalErrorEnabled( h_data.myChordalErrorEnabled );
 805     }
 806     if ( mySurfaceCurvature )
 807       h->SetUseSurfaceCurvature( h_data.mySurfaceCurvature );
 808     h->SetMeshSizeFile         ( h_data.myMeshSizeFile.toUtf8().constData() );
 809
 810     h->SetVarParameter  ( h_data.myElemSizeWeightVar.toLatin1().constData(), "SetElemSizeWeight");
 811     h->SetElemSizeWeight( h_data.myElemSizeWeight );
 812     if ( myNbSurfOptSteps )
 813     {
 814       h->SetVarParameter  ( h_data.myNbSurfOptStepsVar.toLatin1().constData(), "SetNbSurfOptSteps");
 815       h->SetNbSurfOptSteps( h_data.myNbSurfOptSteps );
 816     }
 817     if ( myNbVolOptSteps )
 818     {
 819       h->SetVarParameter ( h_data.myNbVolOptStepsVar.toLatin1().constData(), "SetNbVolOptSteps");
 820       h->SetNbVolOptSteps( h_data.myNbVolOptSteps );
 821     }
 822     if ( myFuseEdges )
 823       h->SetFuseEdges( h_data.myFuseEdges );
 824     h->SetVarParameter    ( h_data.myWorstElemMeasureVar.toLatin1().constData(), "SetWorstElemMeasure");
 825     h->SetWorstElemMeasure( h_data.myWorstElemMeasure );
 826
 827     h->SetUseDelauney( myUseDelauney );
 828     h->SetCheckOverlapping( myCheckOverlapping );
 829     h->SetCheckChartBoundary( myCheckChartBoundary );
 830
 831     //if ( myIs2D )
 832     {
 833       // NETGENPlugin::NETGENPlugin_Hypothesis_2D_var h_2d =
 834       //   NETGENPlugin::NETGENPlugin_Hypothesis_2D::_narrow( h );
 835       // if ( !h_2d->_is_nil() )
 836       //   h_2d->SetQuadAllowed( h_data.myAllowQuadrangles );
 837       if ( myAllowQuadrangles )
 838         h->SetQuadAllowed( h_data.myAllowQuadrangles );
 839     }
 840     if ( myIs2D )
 841     {
 842       NETGENPlugin::NETGENPlugin_RemesherHypothesis_2D_var rh =
 843         NETGENPlugin::NETGENPlugin_RemesherHypothesis_2D::_narrow( h );
 844       if ( !rh->_is_nil() )
 845       {
 846         rh->SetVarParameter   ( h_data.myRidgeAngleVar.toLatin1().constData(), "SetRidgeAngle");
 847         rh->SetRidgeAngle     ( h_data.myRidgeAngle );
 848         rh->SetVarParameter   ( h_data.myEdgeCornerAngleVar.toLatin1().constData(), "SetEdgeCornerAngle");
 849         rh->SetEdgeCornerAngle( h_data.myEdgeCornerAngle );
 850         rh->SetVarParameter   ( h_data.myChartAngleVar.toLatin1().constData(), "SetChartAngle");
 851         rh->SetChartAngle     ( h_data.myChartAngle );
 852         rh->SetVarParameter   ( h_data.myOuterChartAngleVar.toLatin1().constData(), "SetOuterChartAngle");
 853         rh->SetOuterChartAngle( h_data.myOuterChartAngle );
 854
 855         rh->SetVarParameter           ( h_data.myRestHChartDistFactorVar.toLatin1().constData(), "SetRestHChartDistFactor");
 856         rh->SetRestHChartDistFactor   ( h_data.myRestHChartDistFactor );
 857         rh->SetVarParameter           ( h_data.myRestHLineLengthFactorVar.toLatin1().constData(), "SetRestHLineLengthFactor");
 858         rh->SetRestHLineLengthFactor  ( h_data.myRestHLineLengthFactor );
 859         rh->SetVarParameter           ( h_data.myRestHCloseEdgeFactorVar.toLatin1().constData(), "SetRestHCloseEdgeFactor");
 860         rh->SetRestHCloseEdgeFactor   ( h_data.myRestHCloseEdgeFactor );
 861         rh->SetVarParameter           ( h_data.myRestHSurfCurvFactorVar.toLatin1().constData(), "SetRestHSurfCurvFactor");
 862         rh->SetRestHSurfCurvFactor    ( h_data.myRestHSurfCurvFactor );
 863         rh->SetVarParameter           ( h_data.myRestHEdgeAngleFactorVar.toLatin1().constData(), "SetRestHEdgeAngleFactor");
 864         rh->SetRestHEdgeAngleFactor   ( h_data.myRestHEdgeAngleFactor );
 865         rh->SetVarParameter           ( h_data.myRestHSurfMeshCurvFactorVar.toLatin1().constData(), "SetRestHSurfMeshCurvFactor");
 866         rh->SetRestHSurfMeshCurvFactor( h_data.myRestHSurfMeshCurvFactor );
 867
 868         rh->SetRestHChartDistEnable   ( h_data.myRestHChartDistEnable );
 869         rh->SetRestHLineLengthEnable  ( h_data.myRestHLineLengthEnable );
 870         rh->SetRestHCloseEdgeEnable   ( h_data.myRestHCloseEdgeEnable );
 871         rh->SetRestHSurfCurvEnable    ( h_data.myRestHSurfCurvEnable );
 872         rh->SetRestHEdgeAngleEnable   ( h_data.myRestHEdgeAngleEnable );
 873         rh->SetRestHSurfMeshCurvEnable( h_data.myRestHSurfMeshCurvEnable );
 874
 875         rh->SetKeepExistingEdges      ( h_data.myKeepExistingEdges );
 876         rh->SetMakeGroupsOfSurfaces   ( h_data.myMakeGroupsOfSurfaces );
 877         rh->SetFixedEdgeGroup         ( 0 );
 878       }
 879     }
 880     for ( QMapIterator<QString,QString> i(myLocalSizeMap); i.hasNext(); )
 881     {
 882       i.next();
 883       const QString&     entry = i.key();
 884       const QString& localSize = i.value();
 885       if (localSize == "__TO_DELETE__")
 886       {
 887         h->UnsetLocalSizeOnEntry(entry.toLatin1().constData());
 888       }
 889       else
 890       {
 891         h->SetLocalSizeOnEntry(entry.toLatin1().constData(), localSize.toDouble());
 892       }
 893     }
 894   }
 895   catch(const SALOME::SALOME_Exception& ex)
 896   {
 897     SalomeApp_Tools::QtCatchCorbaException(ex);
 898     ok = false;
 899   }
 900   return ok;
 901 }
 902
 903 bool NETGENPluginGUI_HypothesisCreator::readParamsFromWidgets( NetgenHypothesisData& h_data ) const
 904 {
 905   h_data.myName           = myName ? myName->text() : "";
 906   h_data.myMaxSize        = myMaxSize->value();
 907   h_data.myMaxSizeVar     = myMaxSize->text();
 908   h_data.myMinSize        = myMinSize->value();
 909   h_data.myMinSizeVar     = myMinSize->text();
 910   if ( mySecondOrder )
 911     h_data.mySecondOrder  = mySecondOrder->isChecked();
 912   if ( myOptimize )
 913     h_data.myOptimize     = myOptimize->isChecked();
 914   h_data.myFineness       = myFineness->currentIndex();
 915   h_data.myGrowthRate     = myGrowthRate->value();
 916   if ( myNbSegPerEdge )
 917     h_data.myNbSegPerEdge = myNbSegPerEdge->value();
 918   if ( myNbSegPerRadius )
 919     h_data.myNbSegPerRadius = myNbSegPerRadius->value();
 920
 921   h_data.myGrowthRateVar  = myGrowthRate->text();
 922   if ( myNbSegPerEdge )
 923     h_data.myNbSegPerEdgeVar = myNbSegPerEdge->text();
 924   if ( myNbSegPerRadius )
 925     h_data.myNbSegPerRadiusVar = myNbSegPerRadius->text();
 926   if ( myChordalError )
 927   {
 928     h_data.myChordalErrorVar = myChordalError->text();
 929     h_data.myChordalError    = myChordalError->value();
 930     h_data.myChordalErrorEnabled = myChordalError->isEnabled();
 931   }
 932   if ( myAllowQuadrangles )
 933     h_data.myAllowQuadrangles = myAllowQuadrangles->isChecked();
 934
 935   if ( mySurfaceCurvature )
 936     h_data.mySurfaceCurvature = mySurfaceCurvature->isChecked();
 937
 938   if ( myFuseEdges )
 939     h_data.myFuseEdges = myFuseEdges->isChecked();
 940
 941   h_data.myElemSizeWeight    = myElemSizeWeight->value();
 942   h_data.myElemSizeWeightVar = myElemSizeWeight->text();
 943   if ( myNbSurfOptSteps )
 944   {
 945     h_data.myNbSurfOptSteps    = myNbSurfOptSteps->value();
 946     h_data.myNbSurfOptStepsVar = myNbSurfOptSteps->text();
 947   }
 948   if ( myNbVolOptSteps )
 949   {
 950     h_data.myNbVolOptSteps    = myNbVolOptSteps->value();
 951     h_data.myNbVolOptStepsVar = myNbVolOptSteps->text();
 952   }
 953   h_data.myWorstElemMeasure    = myWorstElemMeasure->value();
 954   h_data.myWorstElemMeasureVar = myWorstElemMeasure->text();
 955
 956   h_data.myUseDelauney        = myUseDelauney->isChecked();
 957   h_data.myCheckOverlapping   = myCheckOverlapping->isChecked();
 958   h_data.myCheckChartBoundary = myCheckChartBoundary->isChecked();
 959
 960   if ( myRidgeAngle )
 961   {
 962     h_data.myRidgeAngle                 = myRidgeAngle             ->value();
 963     h_data.myRidgeAngleVar              = myRidgeAngle             ->text();
 964     h_data.myEdgeCornerAngle            = myEdgeCornerAngle        ->value();
 965     h_data.myEdgeCornerAngleVar         = myEdgeCornerAngle        ->text();
 966     h_data.myChartAngle                 = myChartAngle             ->value();
 967     h_data.myChartAngleVar              = myChartAngle             ->text();
 968     h_data.myOuterChartAngle            = myOuterChartAngle        ->value();
 969     h_data.myOuterChartAngleVar         = myOuterChartAngle        ->text();
 970     h_data.myRestHChartDistFactor       = myRestHChartDistFactor   ->value();
 971     h_data.myRestHChartDistFactorVar    = myRestHChartDistFactor   ->text();
 972     h_data.myRestHLineLengthFactor      = myRestHLineLengthFactor  ->value();
 973     h_data.myRestHLineLengthFactorVar   = myRestHLineLengthFactor  ->text();
 974     h_data.myRestHCloseEdgeFactor       = myRestHCloseEdgeFactor   ->value();
 975     h_data.myRestHCloseEdgeFactorVar    = myRestHCloseEdgeFactor   ->text();
 976     h_data.myRestHSurfCurvFactor        = myRestHSurfCurvFactor    ->value();
 977     h_data.myRestHSurfCurvFactorVar     = myRestHSurfCurvFactor    ->text();
 978     h_data.myRestHEdgeAngleFactor       = myRestHEdgeAngleFactor   ->value();
 979     h_data.myRestHEdgeAngleFactorVar    = myRestHEdgeAngleFactor   ->text();
 980     h_data.myRestHSurfMeshCurvFactor    = myRestHSurfMeshCurvFactor->value();
 981     h_data.myRestHSurfMeshCurvFactorVar = myRestHSurfMeshCurvFactor->text();
 982     h_data.myRestHChartDistEnable       = myRestHChartDistEnable   ->isChecked();
 983     h_data.myRestHLineLengthEnable      = myRestHLineLengthEnable  ->isChecked();
 984     h_data.myRestHCloseEdgeEnable       = myRestHCloseEdgeEnable   ->isChecked();
 985     h_data.myRestHSurfCurvEnable        = myRestHSurfCurvEnable    ->isChecked();
 986     h_data.myRestHEdgeAngleEnable       = myRestHEdgeAngleEnable   ->isChecked();
 987     h_data.myRestHSurfMeshCurvEnable    = myRestHSurfMeshCurvEnable->isChecked();
 988     h_data.myKeepExistingEdges          = myKeepExistingEdges      ->isChecked();
 989     h_data.myMakeGroupsOfSurfaces       = myMakeGroupsOfSurfaces   ->isChecked();
 990   }
 991
 992   if ( myLocalSizeTable )
 993   {
 994     NETGENPluginGUI_HypothesisCreator* that = (NETGENPluginGUI_HypothesisCreator*)this;
 995     int nbRows = myLocalSizeTable->rowCount();
 996     for(int row=0 ; row < nbRows ; row++)
 997     {
 998       QString entry = myLocalSizeTable->item(row, LSZ_ENTRY_COLUMN)->text();
 999       QString localSize = myLocalSizeTable->item(row, LSZ_LOCALSIZE_COLUMN)->text().trimmed();
1000       that->myLocalSizeMap[entry] = localSize;
1001     }
1002     h_data.myMeshSizeFile = myMeshSizeFile->text();
1003   }
1004   return true;
1005 }
1006
1007 void NETGENPluginGUI_HypothesisCreator::onChordalErrorEnabled()
1008 {
1009   myChordalError->setEnabled( myChordalErrorEnabled->isChecked() );
1010 }
1011
1012 void NETGENPluginGUI_HypothesisCreator::onSurfaceCurvatureChanged()
1013 {
1014   bool isSurfaceCurvature = (mySurfaceCurvature ? mySurfaceCurvature->isChecked() : true);
1015   bool isCustom           = (myFineness->currentIndex() == UserDefined);
1016   //myFineness->setEnabled(isSurfaceCurvature);
1017   myGrowthRate->setEnabled(isCustom);
1018   if ( myNbSegPerEdge )
1019     myNbSegPerEdge->setEnabled(isCustom && isSurfaceCurvature);
1020   if ( myNbSegPerRadius )
1021     myNbSegPerRadius->setEnabled(isCustom && isSurfaceCurvature);
1022   // if ( myChordalError )
1023   // {
1024   //   myChordalError->setEnabled( isSurfaceCurvature );
1025   //   myChordalErrorEnabled->setEnabled( isSurfaceCurvature );
1026   // }
1027 }
1028
1029 void NETGENPluginGUI_HypothesisCreator::onFinenessChanged()
1030 {
1031   bool isCustom = (myFineness->currentIndex() == UserDefined);
1032
1033   myGrowthRate->setEnabled(isCustom);
1034   if ( myNbSegPerEdge )
1035     myNbSegPerEdge->setEnabled(isCustom);
1036   if ( myNbSegPerRadius )
1037     myNbSegPerRadius->setEnabled(isCustom);
1038
1039   if (!isCustom)
1040   {
1041     double aGrowthRate, aNbSegPerEdge, aNbSegPerRadius;
1042
1043     switch ( myFineness->currentIndex() )
1044     {
1045     case VeryCoarse:
1046       aGrowthRate     = 0.7;
1047       aNbSegPerEdge   = 0.3;
1048       aNbSegPerRadius = 1;
1049       break;
1050     case Coarse:
1051       aGrowthRate     = 0.5;
1052       aNbSegPerEdge   = 0.5;
1053       aNbSegPerRadius = 1.5;
1054       break;
1055     case Fine:
1056       aGrowthRate     = 0.2;
1057       aNbSegPerEdge   = 2;
1058       aNbSegPerRadius = 3;
1059       break;
1060     case VeryFine:
1061       aGrowthRate     = 0.1;
1062       aNbSegPerEdge   = 3;
1063       aNbSegPerRadius = 5;
1064       break;
1065     case Moderate:
1066     default:
1067       aGrowthRate     = 0.3;
1068       aNbSegPerEdge   = 1;
1069       aNbSegPerRadius = 2;
1070       break;
1071     }
1072
1073     myGrowthRate->setValue( aGrowthRate );
1074     if ( myNbSegPerEdge )
1075       myNbSegPerEdge->setValue( aNbSegPerEdge );
1076     if ( myNbSegPerRadius )
1077       myNbSegPerRadius->setValue( aNbSegPerRadius );
1078   }
1079 }
1080
1081 void NETGENPluginGUI_HypothesisCreator::onAddLocalSizeOnVertex()
1082 {
1083   addLocalSizeOnShape(TopAbs_VERTEX);
1084 }
1085
1086 void NETGENPluginGUI_HypothesisCreator::onAddLocalSizeOnEdge()
1087 {
1088   addLocalSizeOnShape(TopAbs_EDGE);
1089 }
1090
1091 void NETGENPluginGUI_HypothesisCreator::onAddLocalSizeOnFace()
1092 {
1093   addLocalSizeOnShape(TopAbs_FACE);
1094 }
1095
1096 void NETGENPluginGUI_HypothesisCreator::onAddLocalSizeOnSolid()
1097 {
1098   addLocalSizeOnShape(TopAbs_SOLID);
1099 }
1100
1101 void NETGENPluginGUI_HypothesisCreator::addLocalSizeOnShape(TopAbs_ShapeEnum typeShapeAsked)
1102 {
1103   NETGENPlugin::NETGENPlugin_Hypothesis_var h = NETGENPlugin::NETGENPlugin_Hypothesis::_narrow(initParamsHypothesis());
1104   GeomSelectionTools* geomSelectionTools = getGeomSelectionTools();
1105   LightApp_SelectionMgr* mySel = geomSelectionTools->selectionMgr();
1106   SALOME_ListIO ListSelectedObjects;
1107   mySel->selectedObjects(ListSelectedObjects, NULL, false );
1108   SALOME_ListIteratorOfListIO Object_It(ListSelectedObjects);
1109   for ( ; Object_It.More() ; Object_It.Next())
1110   {
1111     Handle(SALOME_InteractiveObject) anObject = Object_It.Value();
1112     std::string          entry = geomSelectionTools->getEntryOfObject(anObject);
1113     std::string      shapeName = anObject->getName();
1114     TopAbs_ShapeEnum shapeType = geomSelectionTools->entryToShapeType(entry);
1115     if (shapeType == TopAbs_SHAPE)
1116     {
1117       // E.A. if shapeType == TopAbs_SHAPE, it is NOT a TopoDS_Shape !!!
1118       continue;
1119     }
1120     // --
1121     if(shapeType != typeShapeAsked)
1122     {
1123       continue;
1124     }
1125     // --
1126     myLocalSizeTable->setFocus();
1127     QString shapeEntry = QString::fromStdString(entry);
1128     if (myLocalSizeMap.contains(shapeEntry) &&
1129         myLocalSizeMap[shapeEntry] != "__TO_DELETE__")
1130       continue;
1131
1132     double phySize = h->GetMaxSize();
1133     std::ostringstream oss;
1134     oss << phySize;
1135     QString localSize;
1136     localSize  = QString::fromStdString(oss.str());
1137     // --
1138     int row = myLocalSizeTable->rowCount() ;
1139     myLocalSizeTable->setRowCount(row+1);
1140     myLocalSizeTable->setItem(row, LSZ_ENTRY_COLUMN, new QTableWidgetItem(shapeEntry));
1141     myLocalSizeTable->item(row, LSZ_ENTRY_COLUMN )->setFlags(0);
1142     myLocalSizeTable->setItem(row, LSZ_NAME_COLUMN, new QTableWidgetItem(QString::fromStdString(shapeName)));
1143     myLocalSizeTable->item(row, LSZ_NAME_COLUMN )->setFlags(0);
1144     myLocalSizeTable->setItem(row, LSZ_LOCALSIZE_COLUMN, new QTableWidgetItem(localSize));
1145     myLocalSizeTable->item(row, LSZ_LOCALSIZE_COLUMN )->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled);
1146     myLocalSizeTable->resizeColumnToContents(LSZ_NAME_COLUMN);
1147     myLocalSizeTable->resizeColumnToContents(LSZ_LOCALSIZE_COLUMN);
1148     myLocalSizeTable->clearSelection();
1149     myLocalSizeTable->scrollToItem( myLocalSizeTable->item( row, LSZ_LOCALSIZE_COLUMN ) );
1150     // --
1151   }
1152 }
1153
1154 void NETGENPluginGUI_HypothesisCreator::onRemoveLocalSizeOnShape()
1155 {
1156   QList<int> selectedRows;
1157   QList<QTableWidgetItem*> selected = myLocalSizeTable->selectedItems();
1158   QTableWidgetItem* item;
1159   int row;
1160   foreach(item, selected) {
1161     row = item->row();
1162     if (!selectedRows.contains(row))
1163       selectedRows.append( row );
1164   }
1165   qSort( selectedRows );
1166   QListIterator<int> it( selectedRows );
1167   it.toBack();
1168   while (it.hasPrevious())
1169   {
1170     row = it.previous();
1171     QString entry = myLocalSizeTable->item(row,LSZ_ENTRY_COLUMN)->text();
1172     if (myLocalSizeMap.contains(entry))
1173     {
1174       myLocalSizeMap[entry] = "__TO_DELETE__";
1175     }
1176     myLocalSizeTable->removeRow(row );
1177   }
1178   myLocalSizeTable->resizeColumnToContents(LSZ_NAME_COLUMN);
1179   myLocalSizeTable->resizeColumnToContents(LSZ_LOCALSIZE_COLUMN);
1180 }
1181
1182 void NETGENPluginGUI_HypothesisCreator::onSetLocalSize(int row,int col)
1183 {
1184   if (col == LSZ_LOCALSIZE_COLUMN) {
1185     QString     entry = myLocalSizeTable->item(row, LSZ_ENTRY_COLUMN)->text();
1186     QString localSize = myLocalSizeTable->item(row, LSZ_LOCALSIZE_COLUMN)->text().trimmed();
1187     myLocalSizeMap[entry] = localSize;
1188     myLocalSizeTable->resizeColumnToContents(LSZ_LOCALSIZE_COLUMN);
1189   }
1190 }
1191
1192 void NETGENPluginGUI_HypothesisCreator::onSetSizeFile()
1193 {
1194   QString dir = SUIT_FileDlg::getFileName( dlg(), QString(),
1195                                            QStringList() << tr( "ALL_FILES_FILTER" ) + "  (*)");
1196   myMeshSizeFile->setText( dir );
1197 }
1198
1199 void NETGENPluginGUI_HypothesisCreator::onSTLEnable()
1200 {
1201   myRestHChartDistFactor   ->setEnabled( myRestHChartDistEnable   ->isChecked() );
1202   myRestHLineLengthFactor  ->setEnabled( myRestHLineLengthEnable  ->isChecked() );
1203   myRestHCloseEdgeFactor   ->setEnabled( myRestHCloseEdgeEnable   ->isChecked() );
1204   myRestHSurfCurvFactor    ->setEnabled( myRestHSurfCurvEnable    ->isChecked() );
1205   myRestHEdgeAngleFactor   ->setEnabled( myRestHEdgeAngleEnable   ->isChecked() );
1206   myRestHSurfMeshCurvFactor->setEnabled( myRestHSurfMeshCurvEnable->isChecked() );
1207 }
1208
1209 GeomSelectionTools* NETGENPluginGUI_HypothesisCreator::getGeomSelectionTools()
1210 {
1211   if (myGeomSelectionTools == NULL) {
1212     delete myGeomSelectionTools;
1213     myGeomSelectionTools = new GeomSelectionTools();
1214   }
1215   return myGeomSelectionTools;
1216 }
1217
1218 QString NETGENPluginGUI_HypothesisCreator::caption() const
1219 {
1220   return tr( myIs2D ? "NETGEN_2D_TITLE" : "NETGEN_3D_TITLE");
1221 }
1222
1223 QPixmap NETGENPluginGUI_HypothesisCreator::icon() const
1224 {
1225   QString hypIconName = tr( myIs2D ?
1226                             "ICON_DLG_NETGEN_PARAMETERS_2D" :
1227                             "ICON_DLG_NETGEN_PARAMETERS");
1228   return SUIT_Session::session()->resourceMgr()->loadPixmap( "NETGENPlugin", hypIconName );
1229 }
1230
1231 QString NETGENPluginGUI_HypothesisCreator::type() const
1232 {
1233   return tr( myIs2D ? "NETGEN_2D_HYPOTHESIS" : "NETGEN_3D_HYPOTHESIS");
1234 }
1235
1236 QString NETGENPluginGUI_HypothesisCreator::helpPage() const
1237 {
1238   return "netgen_2d_3d_hypo_page.html";
1239 }