src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx

   1         //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D
   2 //
   3 //  This library is free software; you can redistribute it and/or
   4 //  modify it under the terms of the GNU Lesser General Public
   5 //  License as published by the Free Software Foundation; either
   6 //  version 2.1 of the License.
   7 //
   8 //  This library is distributed in the hope that it will be useful,
   9 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 //  Lesser General Public License for more details.
  12 //
  13 //  You should have received a copy of the GNU Lesser General Public
  14 //  License along with this library; if not, write to the Free Software
  15 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // ---
  20 // File    : BLSURFPluginGUI_HypothesisCreator.cxx
  21 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
  22 //           & Aurelien ALLEAUME (DISTENE)
  23 //           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
  24 // ---
  25 //
  26 #include "BLSURFPluginGUI_HypothesisCreator.h"
  27
  28 #include <SMESHGUI_Utils.h>
  29 #include <SMESHGUI_HypothesesUtils.h>
  30 #include <SMESHGUI_Dialog.h>
  31
  32 #include <SUIT_Session.h>
  33 #include <SUIT_MessageBox.h>
  34 #include <SUIT_ResourceMgr.h>
  35 #include <SalomeApp_Tools.h>
  36 #include <SalomeApp_DoubleSpinBox.h>
  37
  38 #include <QComboBox>
  39 #include <QLabel>
  40 #include <QGroupBox>
  41 #include <QFrame>
  42 #include <QVBoxLayout>
  43 #include <QHBoxLayout>
  44 #include <QGridLayout>
  45 #include <QLineEdit>
  46 #include <QCheckBox>
  47 #include <QTabWidget>
  48 #include <QSpinBox>
  49 #include <QPushButton>
  50 #include <QMenu>
  51 #include <QTableWidget>
  52 #include <QHeaderView>
  53 #include <QApplication>
  54 #include <QRadioButton>
  55
  56 #include <QStandardItemModel>
  57 #include <QStandardItem>
  58 #include <QTreeWidget>
  59 #include <QTreeWidgetItem>
  60 #include <QModelIndexList>
  61
  62 #include <LightApp_SelectionMgr.h>
  63 #include <SalomeApp_Application.h>
  64 #include <SALOME_ListIO.hxx>
  65 #include <SALOME_ListIteratorOfListIO.hxx>
  66
  67 #include <GEOM_Client.hxx>
  68 #include <TopoDS_Shape.hxx>
  69 #include <SMESH_Gen_i.hxx>
  70 #include <boost/shared_ptr.hpp>
  71 #include <structmember.h>
  72
  73 // #include <GeomSelectionTools.h>
  74 #define WITH_SIZE_BOUNDARIES
  75
  76 enum Topology {
  77     FromCAD,
  78     Process,
  79     Process2
  80   } ;
  81
  82 enum PhysicalMesh
  83   {
  84     DefaultSize = 0,
  85     PhysicalUserDefined,
  86     SizeMap
  87   };
  88
  89 enum GeometricMesh
  90   {
  91     DefaultGeom = 0,
  92     UserDefined
  93   };
  94
  95 enum {
  96   STD_TAB = 0,
  97   ADV_TAB,
  98   SMP_TAB,
  99   ENF_TAB,
 100   OPTION_ID_COLUMN = 0,
 101   OPTION_NAME_COLUMN,
 102   OPTION_VALUE_COLUMN,
 103   NB_COLUMNS,
 104   SMP_ENTRY_COLUMN = 0,
 105   SMP_NAME_COLUMN,
 106   SMP_SIZEMAP_COLUMN,
 107   SMP_NB_COLUMNS
 108 };
 109
 110 enum {
 111   SMP_BTNS = 0,
 112 //   SMP_ATTRACTOR_BTN,
 113 //   SMP_SEPARATOR1,
 114   SMP_POINT_BTN,
 115   SMP_EDGE_BTN,
 116   SMP_SURFACE_BTN,
 117   SMP_SEPARATOR2,
 118   SMP_REMOVE_BTN,
 119 };
 120
 121 // Enforced verteces inputs
 122 enum {
 123   ENF_VER_BTNS = 0,
 124   ENF_VER_X_COORD = 0,
 125   ENF_VER_Y_COORD,
 126   ENF_VER_Z_COORD,
 127   ENF_VER_VERTEX_BTN,
 128   ENF_VER_SEPARATOR,
 129   ENF_VER_REMOVE_BTN,
 130 };
 131
 132 // Enforced verteces array columns
 133 enum {
 134   ENF_VER_NAME_COLUMN = 0,
 135   ENF_VER_ENTRY_COLUMN,
 136   ENF_VER_X_COLUMN,
 137   ENF_VER_Y_COLUMN,
 138   ENF_VER_Z_COLUMN,
 139   ENF_VER_NB_COLUMNS
 140 };
 141
 142
 143 /**************************************************
 144  Begin initialization Python structures and objects
 145 ***************************************************/
 146
 147 typedef struct {
 148   PyObject_HEAD
 149   int softspace;
 150   std::string *out;
 151   } PyStdOut;
 152
 153 static void
 154 PyStdOut_dealloc(PyStdOut *self)
 155 {
 156   PyObject_Del(self);
 157 }
 158
 159 static PyObject *
 160 PyStdOut_write(PyStdOut *self, PyObject *args)
 161 {
 162   char *c;
 163   int l;
 164   if (!PyArg_ParseTuple(args, "t#:write",&c, &l))
 165     return NULL;
 166
 167   //std::cerr << c ;
 168   *(self->out)=*(self->out)+c;
 169
 170   Py_INCREF(Py_None);
 171   return Py_None;
 172 }
 173
 174 static PyMethodDef PyStdOut_methods[] = {
 175   {"write",  (PyCFunction)PyStdOut_write,  METH_VARARGS,
 176     PyDoc_STR("write(string) -> None")},
 177   {NULL,    NULL}   /* sentinel */
 178 };
 179
 180 static PyMemberDef PyStdOut_memberlist[] = {
 181   {"softspace", T_INT,  offsetof(PyStdOut, softspace), 0,
 182    "flag indicating that a space needs to be printed; used by print"},
 183   {NULL} /* Sentinel */
 184 };
 185
 186 static PyTypeObject PyStdOut_Type = {
 187   /* The ob_type field must be initialized in the module init function
 188    * to be portable to Windows without using C++. */
 189   PyObject_HEAD_INIT(NULL)
 190   0,                            /*ob_size*/
 191   "PyOut",                      /*tp_name*/
 192   sizeof(PyStdOut),             /*tp_basicsize*/
 193   0,                            /*tp_itemsize*/
 194   /* methods */
 195   (destructor)PyStdOut_dealloc, /*tp_dealloc*/
 196   0,                            /*tp_print*/
 197   0,                            /*tp_getattr*/
 198   0,                            /*tp_setattr*/
 199   0,                            /*tp_compare*/
 200   0,                            /*tp_repr*/
 201   0,                            /*tp_as_number*/
 202   0,                            /*tp_as_sequence*/
 203   0,                            /*tp_as_mapping*/
 204   0,                            /*tp_hash*/
 205   0,                            /*tp_call*/
 206   0,                            /*tp_str*/
 207   PyObject_GenericGetAttr,      /*tp_getattro*/
 208   /* softspace is writable:  we must supply tp_setattro */
 209   PyObject_GenericSetAttr,      /* tp_setattro */
 210   0,                            /*tp_as_buffer*/
 211   Py_TPFLAGS_DEFAULT,           /*tp_flags*/
 212   0,                            /*tp_doc*/
 213   0,                            /*tp_traverse*/
 214   0,                            /*tp_clear*/
 215   0,                            /*tp_richcompare*/
 216   0,                            /*tp_weaklistoffset*/
 217   0,                            /*tp_iter*/
 218   0,                            /*tp_iternext*/
 219   PyStdOut_methods,             /*tp_methods*/
 220   PyStdOut_memberlist,          /*tp_members*/
 221   0,                            /*tp_getset*/
 222   0,                            /*tp_base*/
 223   0,                            /*tp_dict*/
 224   0,                            /*tp_descr_get*/
 225   0,                            /*tp_descr_set*/
 226   0,                            /*tp_dictoffset*/
 227   0,                            /*tp_init*/
 228   0,                            /*tp_alloc*/
 229   0,                            /*tp_new*/
 230   0,                            /*tp_free*/
 231   0,                            /*tp_is_gc*/
 232 };
 233
 234 PyObject * newPyStdOut( std::string& out )
 235 {
 236   PyStdOut *self;
 237   self = PyObject_New(PyStdOut, &PyStdOut_Type);
 238   if (self == NULL)
 239     return NULL;
 240   self->softspace = 0;
 241   self->out=&out;
 242   return (PyObject*)self;
 243 }
 244
 245 /*************************************************
 246 End initialization Python structures and objects
 247 **************************************************/
 248
 249
 250 class QDoubleValidator;
 251
 252 //
 253 // BEGIN EnforcedTreeWidgetDelegate
 254 //
 255
 256 EnforcedTreeWidgetDelegate::EnforcedTreeWidgetDelegate(QObject *parent)
 257   : QItemDelegate(parent)
 258 {
 259 }
 260
 261 QWidget *EnforcedTreeWidgetDelegate::createEditor(QWidget *parent,
 262                                               const QStyleOptionViewItem & option ,
 263                                               const QModelIndex & index ) const
 264 {
 265   QLineEdit *editor = new QLineEdit(parent);
 266   if (index.column() == ENF_VER_X_COLUMN || \
 267     index.column() == ENF_VER_Y_COLUMN || \
 268     index.column() == ENF_VER_Z_COLUMN)
 269     editor->setValidator(new QDoubleValidator(parent));
 270
 271   return editor;
 272 }
 273
 274 void EnforcedTreeWidgetDelegate::setEditorData(QWidget *editor,
 275                                            const QModelIndex &index) const
 276 {
 277   QString value = index.model()->data(index, Qt::EditRole).toString();
 278
 279   QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
 280   lineEdit->setText(value);
 281 }
 282
 283 void EnforcedTreeWidgetDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
 284                                           const QModelIndex &index) const
 285 {
 286   QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
 287
 288   if (index.column() == ENF_VER_X_COLUMN || \
 289     index.column() == ENF_VER_Y_COLUMN || \
 290     index.column() == ENF_VER_Z_COLUMN)
 291   {
 292     if (not vertexExists(model, index, lineEdit->text())) {
 293       bool ok;
 294       double value = lineEdit->text().toDouble(&ok);
 295       if (ok)
 296         model->setData(index, value, Qt::EditRole);
 297     }
 298   }
 299   else if (index.column() == ENF_VER_NAME_COLUMN) {
 300     QString value = lineEdit->text();
 301     if (not vertexExists(model, index, value))
 302       model->setData(index, value, Qt::EditRole);
 303 //     MESSAGE("Value " << value.toString().toStdString() << " was set at index(" << index.row() << "," << index.column() << ")");
 304   }
 305 }
 306
 307 void EnforcedTreeWidgetDelegate::updateEditorGeometry(QWidget *editor,
 308     const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
 309 {
 310   editor->setGeometry(option.rect);
 311 }
 312
 313 bool EnforcedTreeWidgetDelegate::vertexExists(QAbstractItemModel *model,
 314     const QModelIndex &index, QString value) const
 315 {
 316   bool exists = false;
 317   QModelIndex parent = index.parent();
 318   int row = index.row();
 319   int col = index.column();
 320
 321   if (parent.isValid()) {
 322     if (col == ENF_VER_X_COLUMN || col == ENF_VER_Y_COLUMN || col == ENF_VER_Z_COLUMN) {
 323       double x, y, z;
 324       if (col == ENF_VER_X_COLUMN) {
 325         x = value.toDouble();
 326         y = parent.child(row, ENF_VER_Y_COLUMN).data(Qt::EditRole).toDouble();
 327         z = parent.child(row, ENF_VER_Z_COLUMN).data(Qt::EditRole).toDouble();
 328       }
 329       if (col == ENF_VER_Y_COLUMN) {
 330         y = value.toDouble();
 331         x = parent.child(row, ENF_VER_X_COLUMN).data(Qt::EditRole).toDouble();
 332         z = parent.child(row, ENF_VER_Z_COLUMN).data(Qt::EditRole).toDouble();
 333       }
 334       if (col == ENF_VER_Z_COLUMN) {
 335         z = value.toDouble();
 336         x = parent.child(row, ENF_VER_X_COLUMN).data(Qt::EditRole).toDouble();
 337         y = parent.child(row, ENF_VER_Y_COLUMN).data(Qt::EditRole).toDouble();
 338       }
 339       // MESSAGE("Checking for existing vertex " << x << ", " << y << "," << z);
 340       int nbChildren = model->rowCount(parent);
 341       for (int i = 0 ; i < nbChildren ; i++) {
 342         if (i != row) {
 343           double childX = parent.child(i, ENF_VER_X_COLUMN).data(Qt::EditRole).toDouble();
 344           double childY = parent.child(i, ENF_VER_Y_COLUMN).data(Qt::EditRole).toDouble();
 345           double childZ = parent.child(i, ENF_VER_Z_COLUMN).data(Qt::EditRole).toDouble();
 346 //           MESSAGE("Vertex: " << childX << ", " << childY << "," << childZ);
 347           if ((childX == x) && (childY == y) && (childZ == z)) {
 348 //             MESSAGE("Found !");
 349             exists = true;
 350             break;
 351           }
 352         }
 353       }
 354     }
 355     else if (index.column() == ENF_VER_NAME_COLUMN) {
 356       int nbChildren = model->rowCount(parent);
 357       for (int i = 0 ; i < nbChildren ; i++) {
 358         if (i != row) {
 359           QString childName = parent.child(i, ENF_VER_NAME_COLUMN).data(Qt::EditRole).toString();
 360           if (childName == value) {
 361             exists = true;
 362             break;
 363           }
 364         }
 365       }
 366     }
 367   }
 368
 369   return exists;
 370 }
 371
 372 //
 373 // END EnforcedTreeWidgetDelegate
 374 //
 375
 376
 377 /**
 378  * \brief {BLSURFPluginGUI_HypothesisCreator constructor}
 379  * @param theHypType Name of the hypothesis type (here BLSURF_Parameters)
 380  *
 381  * */
 382 BLSURFPluginGUI_HypothesisCreator::BLSURFPluginGUI_HypothesisCreator( const QString& theHypType )
 383   : SMESHGUI_GenericHypothesisCreator( theHypType )
 384 {
 385   MESSAGE("BLSURFPluginGUI_HypothesisCreator::BLSURFPluginGUI_HypothesisCreator");
 386   this->mySMPMap.clear();
 387
 388   GeomToolSelected = NULL;
 389   GeomToolSelected = getGeomSelectionTool();
 390
 391   aSel = GeomToolSelected->selectionMgr();
 392
 393   /* Initialize the Python interpreter */
 394   if (not Py_IsInitialized())
 395     throw ("Error: Python interpreter is not initialized");
 396   PyGILState_STATE gstate;
 397   gstate = PyGILState_Ensure();
 398
 399   main_mod = NULL;
 400   main_mod = PyImport_AddModule("__main__");
 401
 402   main_dict = NULL;
 403   main_dict = PyModule_GetDict(main_mod);
 404
 405   PyRun_SimpleString("from math import *");
 406   PyGILState_Release(gstate);
 407
 408 }
 409
 410 BLSURFPluginGUI_HypothesisCreator::~BLSURFPluginGUI_HypothesisCreator()
 411 {
 412 }
 413
 414 /**
 415  * \brief {Get or create the geom selection tool for active study}
 416  * */
 417 GeomSelectionTools* BLSURFPluginGUI_HypothesisCreator::getGeomSelectionTool()
 418 {
 419 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::getGeomSelectionTool");
 420   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
 421   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
 422 //   MESSAGE("aStudy->StudyId(): " << aStudy->StudyId());
 423   if (that->GeomToolSelected == NULL or that->GeomToolSelected->getMyStudy() != aStudy) {
 424 //     MESSAGE("GeomToolSelected is created");
 425     that->GeomToolSelected = new GeomSelectionTools(aStudy);
 426   }
 427 //   else
 428 //     MESSAGE("GeomToolSelected already exists");
 429 //   MESSAGE("that->GeomToolSelected->getMyStudy()->StudyId(): " << that->GeomToolSelected->getMyStudy()->StudyId());
 430   return that->GeomToolSelected;
 431 }
 432
 433 namespace {
 434   inline bool isDouble( const QString& theText, const bool emptyOK=false ) {
 435     QString str = theText.trimmed();
 436     bool isOk = true;
 437     if ( !str.isEmpty() )
 438       str.toDouble(&isOk);
 439     else
 440       isOk = emptyOK;
 441     return isOk;
 442   }
 443 }
 444
 445
 446 bool BLSURFPluginGUI_HypothesisCreator::checkParams() const
 447 {
 448   MESSAGE("BLSURFPluginGUI_HypothesisCreator::checkParams");
 449   bool ok = true;
 450   if ( !isDouble( myPhySize->text(), false )) {
 451     if ( myPhySize->text().isEmpty() )
 452       myPhySize->setText(tr("OBLIGATORY_VALUE"));
 453     myPhySize->selectAll();
 454     ok = false;
 455   }
 456   if ( !isDouble( myPhyMin->text(), true )) {
 457     myPhyMin->selectAll();
 458     ok = false;
 459   }
 460   if ( !isDouble( myPhyMax->text(), true )) {
 461     myPhyMax->selectAll();
 462     ok = false;
 463   }
 464   if ( !isDouble( myGeoMin->text(), true )) {
 465     myGeoMin->selectAll();
 466     ok = false;
 467   }
 468   if ( !isDouble( myGeoMin->text(), true )) {
 469     myGeoMin->selectAll();
 470     ok = false;
 471   }
 472   if ( ok )
 473   {
 474     myOptionTable->setFocus();
 475     QApplication::instance()->processEvents();
 476
 477     BLSURFPlugin::BLSURFPlugin_Hypothesis_var h =
 478       BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis() );
 479
 480     int row = 0, nbRows = myOptionTable->rowCount();
 481     for ( ; row < nbRows; ++row )
 482     {
 483       QString name  = myOptionTable->item( row, OPTION_NAME_COLUMN )->text();
 484       QString value = myOptionTable->item( row, OPTION_VALUE_COLUMN )->text().trimmed();
 485       if ( !value.isEmpty() ) {
 486         try {
 487           h->SetOptionValue( name.toLatin1().constData(), value.toLatin1().constData() );
 488         }
 489         catch ( const SALOME::SALOME_Exception& ex )
 490         {
 491           SUIT_MessageBox::critical( dlg(),
 492                                      tr("SMESH_ERROR"),
 493                                      ex.details.text.in() );
 494           ok = false;
 495         }
 496       }
 497     }
 498     h->SetOptionValues( myOptions ); // restore values
 499   }
 500
 501   // SizeMap and attractors
 502   if ( ok )
 503   {
 504     mySizeMapTable->setFocus();
 505     QApplication::instance()->processEvents();
 506
 507     BLSURFPlugin::BLSURFPlugin_Hypothesis_var h = BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis() );
 508     BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
 509
 510     int row = 0, nbRows = mySizeMapTable->rowCount();
 511     for ( ; row < nbRows; ++row )
 512     {
 513       QString entry   = mySizeMapTable->item( row, SMP_ENTRY_COLUMN )->text();
 514       QString sizeMap = mySizeMapTable->item( row, SMP_SIZEMAP_COLUMN )->text().trimmed();
 515       if ( !sizeMap.isEmpty() ) {
 516         if (that->sizeMapValidationFromRow(row))
 517         {
 518           try {
 519             const char* e = entry.toLatin1().constData();
 520             const char* s = that->mySMPMap[entry].toLatin1().constData();
 521             h->SetSizeMapEntry( e, s );
 522           }
 523           catch ( const SALOME::SALOME_Exception& ex )
 524           {
 525             SUIT_MessageBox::critical( dlg(),
 526                                        tr("SMESH_ERROR"),
 527                                        ex.details.text.in() );
 528             ok = false;
 529           }
 530         }
 531         else {
 532           ok = false;
 533         }
 534       }
 535     }
 536   }
 537
 538   // Enforced verteces
 539   // TODO
 540
 541   return ok;
 542 }
 543
 544 QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
 545 {
 546   MESSAGE("BLSURFPluginGUI_HypothesisCreator::buildFrame");
 547   QFrame* fr = new QFrame( 0 );
 548   QVBoxLayout* lay = new QVBoxLayout( fr );
 549   lay->setMargin( 5 );
 550   lay->setSpacing( 0 );
 551
 552   // tab
 553   QTabWidget* tab = new QTabWidget( fr );
 554   tab->setTabShape( QTabWidget::Rounded );
 555   tab->setTabPosition( QTabWidget::North );
 556   lay->addWidget( tab );
 557
 558   // basic parameters
 559   myStdGroup = new QWidget();
 560   QGridLayout* aStdLayout = new QGridLayout( myStdGroup );
 561   aStdLayout->setSpacing( 6 );
 562   aStdLayout->setMargin( 11 );
 563
 564   int row = 0;
 565   myName = 0;
 566   if( isCreation() ) {
 567     aStdLayout->addWidget( new QLabel( tr( "SMESH_NAME" ), myStdGroup ), row, 0, 1, 1 );
 568     myName = new QLineEdit( myStdGroup );
 569     aStdLayout->addWidget( myName, row++, 1, 1, 1 );
 570   }
 571
 572   aStdLayout->addWidget( new QLabel( tr( "BLSURF_GRADATION" ), myStdGroup ), row, 0, 1, 1 );
 573   myGradation = new SalomeApp_DoubleSpinBox( myStdGroup );
 574   aStdLayout->addWidget( myGradation, row++, 1, 1, 1 );
 575   myGradation->setMinimum( 1.1 );
 576   myGradation->setMaximum( 2.5 );
 577   myGradation->setSingleStep( 0.1 );
 578
 579   aStdLayout->addWidget( new QLabel( tr( "BLSURF_PHY_MESH" ), myStdGroup ), row, 0, 1, 1 );
 580   myPhysicalMesh = new QComboBox( myStdGroup );
 581   aStdLayout->addWidget( myPhysicalMesh, row++, 1, 1, 1 );
 582   QStringList physicalTypes;
 583   physicalTypes << tr( "BLSURF_DEFAULT_USER" ) << tr( "BLSURF_CUSTOM_USER" ) << tr( "BLSURF_SIZE_MAP");
 584   myPhysicalMesh->addItems( physicalTypes );
 585
 586   aStdLayout->addWidget( new QLabel( tr( "BLSURF_HPHYDEF" ), myStdGroup), row, 0, 1, 1 );
 587   myPhySize = new QLineEdit( myStdGroup );
 588   aStdLayout->addWidget( myPhySize, row++, 1, 1, 1 );
 589
 590 #ifdef WITH_SIZE_BOUNDARIES
 591   aStdLayout->addWidget( new QLabel( tr( "BLSURF_HPHYMIN" ), myStdGroup ), row, 0, 1, 1 );
 592   myPhyMin = new QLineEdit( myStdGroup );
 593   aStdLayout->addWidget( myPhyMin, row++, 1, 1, 1 );
 594
 595   aStdLayout->addWidget( new QLabel( tr( "BLSURF_HPHYMAX" ), myStdGroup ), row, 0, 1, 1 );
 596   myPhyMax = new QLineEdit( myStdGroup );
 597   aStdLayout->addWidget( myPhyMax, row++, 1, 1, 1 );
 598 #endif
 599
 600   aStdLayout->addWidget( new QLabel( tr( "BLSURF_GEOM_MESH" ), myStdGroup ), row, 0, 1, 1 );
 601   myGeometricMesh = new QComboBox( myStdGroup );
 602   aStdLayout->addWidget( myGeometricMesh, row++, 1, 1, 1 );
 603   QStringList types;
 604   types << tr( "BLSURF_DEFAULT_GEOM" ) << tr( "BLSURF_CUSTOM_GEOM" );
 605   myGeometricMesh->addItems( types );
 606
 607   aStdLayout->addWidget( new QLabel( tr( "BLSURF_ANGLE_MESH_S" ), myStdGroup ), row, 0, 1, 1 );
 608   myAngleMeshS = new SalomeApp_DoubleSpinBox( myStdGroup );
 609   aStdLayout->addWidget( myAngleMeshS, row++, 1, 1, 1 );
 610   myAngleMeshS->setMinimum( 0 );
 611   myAngleMeshS->setMaximum( 16 );
 612   myAngleMeshS->setSingleStep( 0.5 );
 613
 614   aStdLayout->addWidget( new QLabel( tr( "BLSURF_ANGLE_MESH_C" ), myStdGroup ), row, 0, 1, 1 );
 615   myAngleMeshC = new SalomeApp_DoubleSpinBox( myStdGroup );
 616   aStdLayout->addWidget( myAngleMeshC, row++, 1, 1, 1 );
 617   myAngleMeshC->setMinimum( 0 );
 618   myAngleMeshC->setMaximum( 16 );
 619   myAngleMeshC->setSingleStep( 0.5 );
 620
 621 #ifdef WITH_SIZE_BOUNDARIES
 622   aStdLayout->addWidget( new QLabel( tr( "BLSURF_HGEOMIN" ), myStdGroup ), row, 0, 1, 1 );
 623   myGeoMin = new QLineEdit( myStdGroup );
 624   aStdLayout->addWidget( myGeoMin, row++, 1, 1, 1 );
 625
 626   aStdLayout->addWidget( new QLabel( tr( "BLSURF_HGEOMAX" ), myStdGroup ), row, 0, 1, 1 );
 627   myGeoMax = new QLineEdit( myStdGroup );
 628   aStdLayout->addWidget( myGeoMax, row++, 1, 1, 1 );
 629 #endif
 630
 631   myAllowQuadrangles = new QCheckBox( tr( "BLSURF_ALLOW_QUADRANGLES" ), myStdGroup );
 632   aStdLayout->addWidget( myAllowQuadrangles, row++, 0, 1, 2 );
 633
 634   myDecimesh = new QCheckBox( tr( "BLSURF_DECIMESH" ), myStdGroup );
 635   aStdLayout->addWidget( myDecimesh, row++, 0, 1, 2 );
 636
 637   // advanced parameters
 638   myAdvGroup = new QWidget();
 639   QGridLayout* anAdvLayout = new QGridLayout( myAdvGroup );
 640   anAdvLayout->setSpacing( 6 );
 641   anAdvLayout->setMargin( 11 );
 642
 643   anAdvLayout->addWidget( new QLabel( tr( "BLSURF_TOPOLOGY" ), myAdvGroup ), 0, 0, 1, 1 );
 644   myTopology = new QComboBox( myAdvGroup );
 645   anAdvLayout->addWidget( myTopology, 0, 1, 1, 1 );
 646   QStringList topologyTypes;
 647   topologyTypes << tr( "BLSURF_TOPOLOGY_CAD" ) << tr( "BLSURF_TOPOLOGY_PROCESS" ) << tr( "BLSURF_TOPOLOGY_PROCESS2" );
 648   myTopology->addItems( topologyTypes );
 649
 650   anAdvLayout->addWidget( new QLabel( tr( "BLSURF_VERBOSITY" ), myAdvGroup ), 1, 0, 1, 1 );
 651   myVerbosity = new QSpinBox( myAdvGroup );
 652   anAdvLayout->addWidget( myVerbosity, 1, 1, 1, 1 );
 653   myVerbosity->setMinimum( 0 );
 654   myVerbosity->setMaximum( 100 );
 655   myVerbosity->setSingleStep( 5 );
 656
 657   myOptionTable = new QTableWidget( 0, NB_COLUMNS, myAdvGroup );
 658   anAdvLayout->addWidget( myOptionTable, 2, 0, 3, 2 );
 659   QStringList headers;
 660   headers << tr( "OPTION_ID_COLUMN" ) << tr( "OPTION_NAME_COLUMN" ) << tr( "OPTION_VALUE_COLUMN" );
 661   myOptionTable->setHorizontalHeaderLabels( headers );
 662   myOptionTable->horizontalHeader()->hideSection( OPTION_ID_COLUMN );
 663   //myOptionTable->setColumnReadOnly( OPTION_NAME_COLUMN, TRUE );//////
 664   //myOptionTable->setColumnReadOnly( OPTION_VALUE_COLUMN, FALSE );/////
 665   myOptionTable->verticalHeader()->hide();
 666   //myOptionTable->setSelectionBehavior( QAbstractItemView::SelectRows );
 667
 668   QPushButton* addBtn = new QPushButton( tr( "ADD_OPTION"),  myAdvGroup );
 669   anAdvLayout->addWidget( addBtn, 2, 2, 1, 1 );
 670   addBtn->setMenu( new QMenu() );
 671
 672   QPushButton* rmBtn = new QPushButton( tr( "REMOVE_OPTION"), myAdvGroup );
 673   anAdvLayout->addWidget( rmBtn, 3, 2, 1, 1 );
 674
 675   anAdvLayout->setRowStretch( 4, 5 );
 676   anAdvLayout->setColumnStretch( 1, 5 );
 677
 678   // Size Maps parameters
 679
 680   mySmpGroup = new QWidget();
 681   QGridLayout* anSmpLayout = new QGridLayout(mySmpGroup);
 682
 683   mySizeMapTable = new QTableWidget( 0, SMP_NB_COLUMNS, mySmpGroup );
 684   anSmpLayout->addWidget(mySizeMapTable, 1, 0, 8, 1);
 685   QStringList sizeMapHeaders;
 686   sizeMapHeaders << tr( "SMP_ENTRY_COLUMN" )<< tr( "SMP_NAME_COLUMN" ) << tr( "SMP_SIZEMAP_COLUMN" );
 687   mySizeMapTable->setHorizontalHeaderLabels(sizeMapHeaders);
 688   mySizeMapTable->horizontalHeader()->hideSection( SMP_ENTRY_COLUMN );
 689 //   mySizeMapTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
 690   mySizeMapTable->resizeColumnToContents(SMP_NAME_COLUMN);
 691   mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
 692   mySizeMapTable->setAlternatingRowColors(true);
 693   mySizeMapTable->verticalHeader()->hide();
 694
 695 /*
 696   addAttractorButton = new QPushButton(tr("BLSURF_SM_ATTRACTOR"),mySmpGroup);
 697   anSmpLayout->addWidget(addAttractorButton, SMP_ATTRACTOR_BTN, 1, 1, 1);
 698
 699   QFrame *line = new QFrame(mySmpGroup);
 700   line->setFrameShape(QFrame::HLine);
 701   line->setFrameShadow(QFrame::Sunken);
 702   anSmpLayout->addWidget(line, SMP_SEPARATOR1, 1, 1, 1);
 703 */
 704   addSurfaceButton = new QPushButton(tr("BLSURF_SM_SURFACE"),mySmpGroup);
 705   anSmpLayout->addWidget(addSurfaceButton, SMP_SURFACE_BTN, 1, 1, 1);
 706
 707   addEdgeButton = new QPushButton(tr("BLSURF_SM_EDGE"),mySmpGroup);
 708   anSmpLayout->addWidget(addEdgeButton, SMP_EDGE_BTN, 1, 1, 1);
 709
 710   addPointButton = new QPushButton(tr("BLSURF_SM_POINT"),mySmpGroup);
 711   anSmpLayout->addWidget(addPointButton, SMP_POINT_BTN, 1, 1, 1);
 712
 713   QFrame *line2 = new QFrame(mySmpGroup);
 714   line2->setFrameShape(QFrame::HLine);
 715   line2->setFrameShadow(QFrame::Sunken);
 716   anSmpLayout->addWidget(line2, SMP_SEPARATOR2, 1, 1, 1);
 717
 718   removeButton = new QPushButton(tr("BLSURF_SM_REMOVE"),mySmpGroup);
 719   anSmpLayout->addWidget(removeButton, SMP_REMOVE_BTN, 1, 1, 1);
 720
 721   // Enforced verteces parameters
 722
 723   myEnfGroup = new QWidget();
 724   QGridLayout* anEnfLayout = new QGridLayout(myEnfGroup);
 725
 726   myEnforcedTreeWidget = new QTreeWidget(myEnfGroup);
 727   myEnforcedTreeWidget->setColumnCount( ENF_VER_NB_COLUMNS );
 728   myEnforcedTreeWidget->setSortingEnabled(true);
 729   QStringList enforcedHeaders;
 730   enforcedHeaders << tr("BLSURF_ENF_VER_NAME_COLUMN") << tr("BLSURF_ENF_VER_ENTRY_COLUMN") << tr( "BLSURF_ENF_VER_X_COLUMN" )<< tr( "BLSURF_ENF_VER_Y_COLUMN" ) << tr( "BLSURF_ENF_VER_Z_COLUMN" ) ;
 731   myEnforcedTreeWidget->setHeaderLabels(enforcedHeaders);
 732   myEnforcedTreeWidget->setAlternatingRowColors(true);
 733   myEnforcedTreeWidget->setUniformRowHeights(true);
 734   myEnforcedTreeWidget->setAnimated(true);
 735   myEnforcedTreeWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
 736   myEnforcedTreeWidget->setSelectionBehavior(QAbstractItemView::SelectItems);
 737   for (int column = 0; column < ENF_VER_NB_COLUMNS; ++column) {
 738     myEnforcedTreeWidget->header()->setResizeMode(column,QHeaderView::Interactive);
 739     myEnforcedTreeWidget->resizeColumnToContents(column);
 740   }
 741   myEnforcedTreeWidget->hideColumn(ENF_VER_ENTRY_COLUMN);
 742   myEnforcedTreeWidget->setItemDelegate(new EnforcedTreeWidgetDelegate());
 743   anEnfLayout->addWidget(myEnforcedTreeWidget, 0, 0, 8, 1);
 744
 745   QLabel* myXCoordLabel = new QLabel( tr( "BLSURF_ENF_VER_X_LABEL" ), myEnfGroup );
 746   anEnfLayout->addWidget(myXCoordLabel, ENF_VER_X_COORD, 1, 1, 1);
 747   myXCoord = new QLineEdit(myEnfGroup);
 748   myXCoord->setValidator(new QDoubleValidator(myEnfGroup));
 749   anEnfLayout->addWidget(myXCoord, ENF_VER_X_COORD, 2, 1, 1);
 750
 751   QLabel* myYCoordLabel = new QLabel( tr( "BLSURF_ENF_VER_Y_LABEL" ), myEnfGroup );
 752   anEnfLayout->addWidget(myYCoordLabel, ENF_VER_Y_COORD, 1, 1, 1);
 753   myYCoord = new QLineEdit(myEnfGroup);
 754   myYCoord->setValidator(new QDoubleValidator(myEnfGroup));
 755   anEnfLayout->addWidget(myYCoord, ENF_VER_Y_COORD, 2, 1, 1);
 756
 757   QLabel* myZCoordLabel = new QLabel( tr( "BLSURF_ENF_VER_Z_LABEL" ), myEnfGroup );
 758   anEnfLayout->addWidget(myZCoordLabel, ENF_VER_Z_COORD, 1, 1, 1);
 759   myZCoord = new QLineEdit(myEnfGroup);
 760   myZCoord->setValidator(new QDoubleValidator(myEnfGroup));
 761   anEnfLayout->addWidget(myZCoord, ENF_VER_Z_COORD, 2, 1, 1);
 762
 763   addVertexButton = new QPushButton(tr("BLSURF_ENF_VER_VERTEX"),myEnfGroup);
 764   anEnfLayout->addWidget(addVertexButton, ENF_VER_VERTEX_BTN, 1, 1, 2);
 765
 766   QFrame *line = new QFrame(myEnfGroup);
 767   line->setFrameShape(QFrame::HLine);
 768   line->setFrameShadow(QFrame::Sunken);
 769   anEnfLayout->addWidget(line, ENF_VER_SEPARATOR, 1, 1, 2);
 770
 771   removeVertexButton = new QPushButton(tr("BLSURF_ENF_VER_REMOVE"),myEnfGroup);
 772   anEnfLayout->addWidget(removeVertexButton, ENF_VER_REMOVE_BTN, 1, 1, 2);
 773
 774   // ---
 775   tab->insertTab( STD_TAB, myStdGroup, tr( "SMESH_ARGUMENTS" ) );
 776   tab->insertTab( ADV_TAB, myAdvGroup, tr( "BLSURF_ADV_ARGS" ) );
 777   tab->insertTab( SMP_TAB, mySmpGroup, tr( "BLSURF_SIZE_MAP" ) );
 778   tab->insertTab( ENF_TAB, myEnfGroup, tr( "BLSURF_ENF_VER" ) );
 779
 780   tab->setCurrentIndex( STD_TAB );
 781
 782   // ---
 783   connect( myGeometricMesh,    SIGNAL( activated( int ) ),            this,         SLOT( onGeometricMeshChanged() ) );
 784   connect( myPhysicalMesh,     SIGNAL( activated( int ) ),            this,         SLOT( onPhysicalMeshChanged() ) );
 785   connect( addBtn->menu(),     SIGNAL( aboutToShow() ),               this,         SLOT( onAddOption() ) );
 786   connect( addBtn->menu(),     SIGNAL( triggered( QAction* ) ),       this,         SLOT( onOptionChosenInPopup( QAction* ) ) );
 787   connect( rmBtn,              SIGNAL( clicked()),                    this,         SLOT( onDeleteOption() ) );
 788
 789   connect( addSurfaceButton,   SIGNAL( clicked()),                    this,         SLOT( onAddMapOnSurface() ) );
 790   connect( addEdgeButton,      SIGNAL( clicked()),                    this,         SLOT( onAddMapOnEdge() ) );
 791   connect( addPointButton,     SIGNAL( clicked()),                    this,         SLOT( onAddMapOnPoint() ) );
 792   connect( removeButton,       SIGNAL( clicked()),                    this,         SLOT( onRemoveMap() ) );
 793   connect( mySizeMapTable,     SIGNAL( cellChanged ( int, int  )),    this,         SLOT( onSetSizeMap(int,int ) ) );
 794
 795   connect( myEnforcedTreeWidget,SIGNAL( itemClicked(QTreeWidgetItem *, int)), this, SLOT( synchronizeCoords() ) );
 796   connect( myEnforcedTreeWidget,SIGNAL( itemChanged(QTreeWidgetItem *, int)), this, SLOT( update(QTreeWidgetItem *, int) ) );
 797   connect( myEnforcedTreeWidget,SIGNAL( itemSelectionChanged() ),     this,         SLOT( synchronizeCoords() ) );
 798   connect( addVertexButton,    SIGNAL( clicked()),                    this,         SLOT( onAddEnforcedVerteces() ) );
 799   connect( removeVertexButton, SIGNAL( clicked()),                    this,         SLOT( onRemoveEnforcedVertex() ) );
 800
 801   return fr;
 802 }
 803
 804 /** BLSURFPluginGUI_HypothesisCreator::update(item, column)
 805 This method updates the tooltip of a modified item. The QLineEdit widgets content
 806 is synchronized with the coordinates of the enforced vertex clicked in the tree widget.
 807 */
 808 void BLSURFPluginGUI_HypothesisCreator::update(QTreeWidgetItem* item, int column) {
 809 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::updateVertexList");
 810   QVariant x = item->data(ENF_VER_X_COLUMN, Qt::EditRole);
 811   if (not x.isNull()) {
 812     QVariant y = item->data(ENF_VER_Y_COLUMN, Qt::EditRole);
 813     QVariant z = item->data(ENF_VER_Z_COLUMN, Qt::EditRole);
 814     QVariant vertexName = item->data(ENF_VER_NAME_COLUMN, Qt::EditRole);
 815
 816     QTreeWidgetItem* parent = item->parent();
 817     if (parent) {
 818       QString shapeName = parent->data(ENF_VER_NAME_COLUMN, Qt::EditRole).toString();
 819       QString toolTip = shapeName + QString(": ") + vertexName.toString();
 820       toolTip += QString("(") + x.toString();
 821       toolTip += QString(", ") + y.toString();
 822       toolTip += QString(", ") + z.toString();
 823       toolTip += QString(")");
 824       item->setToolTip(ENF_VER_NAME_COLUMN,toolTip);
 825     }
 826
 827     myXCoord->setText(x.toString());
 828     myYCoord->setText(y.toString());
 829     myZCoord->setText(z.toString());
 830   }
 831 }
 832
 833 /** BLSURFPluginGUI_HypothesisCreator::synchronizeCoords()
 834 This method synchronizes the QLineEdit widgets content with the coordinates
 835 of the enforced vertex clicked in the tree widget.
 836 */
 837 void BLSURFPluginGUI_HypothesisCreator::synchronizeCoords() {
 838 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::synchronizeCoords");
 839   QList<QTreeWidgetItem *> items = myEnforcedTreeWidget->selectedItems();
 840   if (not items.isEmpty()) {
 841     QTreeWidgetItem *item;
 842     for (int i=0 ; i < items.size() ; i++) {
 843       item = items[i];
 844       QVariant x = item->data(ENF_VER_X_COLUMN, Qt::EditRole);
 845       if (not x.isNull()) {
 846         QVariant y = item->data(ENF_VER_Y_COLUMN, Qt::EditRole);
 847         QVariant z = item->data(ENF_VER_Z_COLUMN, Qt::EditRole);
 848         myXCoord->setText(x.toString());
 849         myYCoord->setText(y.toString());
 850         myZCoord->setText(z.toString());
 851         break;
 852       }
 853     }
 854   }
 855 }
 856
 857 /** BLSURFPluginGUI_HypothesisCreator::addEnforcedVertex(entry, shapeName, x, y, z)
 858 This method adds an enforced vertex (x,y,z) to shapeName in the tree widget.
 859 */
 860 void BLSURFPluginGUI_HypothesisCreator::addEnforcedVertex(std::string entry, std::string shapeName, double x, double y, double z) {
 861   // Find entry item
 862   QList<QTreeWidgetItem* > theItemList = myEnforcedTreeWidget->findItems(QString(entry.c_str()),Qt::MatchExactly,ENF_VER_ENTRY_COLUMN);
 863   QTreeWidgetItem* theItem;
 864   if (theItemList.empty()) {
 865     theItem = new QTreeWidgetItem();
 866     theItem->setData(ENF_VER_ENTRY_COLUMN, Qt::EditRole, QVariant(entry.c_str()));
 867     theItem->setData(ENF_VER_NAME_COLUMN, Qt::EditRole, QVariant(shapeName.c_str()));
 868     theItem->setToolTip(ENF_VER_NAME_COLUMN,QString(entry.c_str()));
 869     myEnforcedTreeWidget->addTopLevelItem(theItem);
 870   }
 871   else {
 872     theItem = theItemList[0];
 873   }
 874
 875 //   MESSAGE("theItemName is " << theItem->text(ENF_VER_NAME_COLUMN).toStdString());
 876   bool okToCreate = true;
 877
 878   const int nbVert = theItem->childCount();
 879 //   MESSAGE("Number of child rows: " << nbVert);
 880   if (nbVert >0) {
 881     double childValueX,childValueY,childValueZ;
 882     QTreeWidgetItem* child;
 883     for (int row = 0;row<nbVert;row++) {
 884       child = theItem->child(row);
 885       childValueX = child->data(ENF_VER_X_COLUMN,Qt::EditRole).toDouble();
 886       childValueY = child->data(ENF_VER_Y_COLUMN,Qt::EditRole).toDouble();
 887       childValueZ = child->data(ENF_VER_Z_COLUMN,Qt::EditRole).toDouble();
 888       if ((childValueX == x) and (childValueY == y) and (childValueZ == z)) {
 889         okToCreate = false;
 890         break;
 891       }
 892     }
 893   }
 894   if (okToCreate) {
 895     MESSAGE("In " << shapeName << " vertex with coords " << x << ", " << y << ", " << z<< " is created");
 896
 897     QTreeWidgetItem *vertexItem = new QTreeWidgetItem( theItem);
 898     vertexItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled);
 899     int vertexIndex=1;
 900     QString vertexName;
 901     int indexRef = 0;
 902     while(indexRef != vertexIndex) {
 903       indexRef = vertexIndex;
 904       vertexName = QString("Vertex #%1").arg(vertexIndex);
 905       for (int row = 0;row<nbVert;row++) {
 906         QString name = theItem->child(row)->data(ENF_VER_NAME_COLUMN,Qt::EditRole).toString();
 907         if (vertexName == name) {
 908           vertexIndex++;
 909           break;
 910         }
 911       }
 912     }
 913     vertexItem->setData( ENF_VER_NAME_COLUMN, Qt::EditRole, vertexName );
 914     vertexItem->setData( ENF_VER_X_COLUMN, Qt::EditRole, QVariant(x) );
 915     vertexItem->setData( ENF_VER_Y_COLUMN, Qt::EditRole, QVariant(y) );
 916     vertexItem->setData( ENF_VER_Z_COLUMN, Qt::EditRole, QVariant(z) );
 917     QString toolTip = QString(shapeName.c_str())+QString(": ")+vertexName;
 918     toolTip += QString(" (%1, ").arg(x);
 919     toolTip += QString("%1, ").arg(y);
 920     toolTip += QString("%1)").arg(z);
 921     vertexItem->setToolTip(ENF_VER_NAME_COLUMN,toolTip);
 922     theItem->setExpanded(true);
 923     myEnforcedTreeWidget->setCurrentItem(vertexItem,ENF_VER_NAME_COLUMN);
 924   }
 925   else
 926     MESSAGE("In " << shapeName << " vertex with coords " << x << ", " << y << ", " << z<< " already exist: dont create again");
 927 }
 928
 929 /** BLSURFPluginGUI_HypothesisCreator::onAddEnforcedVerteces()
 930 This method is called when a item is added into the enforced verteces tree widget
 931 */
 932 void BLSURFPluginGUI_HypothesisCreator::onAddEnforcedVerteces() {
 933 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::onAddEnforcedVerteces");
 934
 935   for (int column = 0; column < myEnforcedTreeWidget->columnCount(); ++column)
 936     myEnforcedTreeWidget->resizeColumnToContents(column);
 937
 938   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
 939
 940   if ((myXCoord->text().isEmpty()) or (myYCoord->text().isEmpty()) or (myZCoord->text().isEmpty())) return;
 941
 942   double x = myXCoord->text().toDouble();
 943   double y = myYCoord->text().toDouble();
 944   double z = myZCoord->text().toDouble();
 945
 946   TopAbs_ShapeEnum shapeType;
 947   string entry, shapeName;
 948   GeomSelectionTools* myGeomToolSelected = that->getGeomSelectionTool();
 949   LightApp_SelectionMgr* mySel = myGeomToolSelected->selectionMgr();
 950   SALOME_ListIO ListSelectedObjects;
 951   mySel->selectedObjects(ListSelectedObjects, NULL, false );
 952   if (!ListSelectedObjects.IsEmpty()) {
 953     SALOME_ListIteratorOfListIO Object_It(ListSelectedObjects);
 954     for (; Object_It.More(); Object_It.Next()) {
 955       Handle(SALOME_InteractiveObject) anObject = Object_It.Value();
 956       entry     = myGeomToolSelected->getEntryOfObject(anObject);
 957       shapeName = anObject->getName();
 958       shapeType = myGeomToolSelected->entryToShapeType(entry);
 959 //       MESSAGE("Object Name = " << shapeName << "& Type is " << anObject->getComponentDataType() << " & ShapeType is " << shapeType);
 960       if (shapeType == TopAbs_FACE) {
 961         addEnforcedVertex(entry, shapeName, x, y, z);
 962       }
 963     }
 964   }
 965   for (int column = 0; column < myEnforcedTreeWidget->columnCount(); ++column)
 966     myEnforcedTreeWidget->resizeColumnToContents(column);
 967
 968   if ( myPhysicalMesh->currentIndex() != SizeMap ) {
 969     myPhysicalMesh->setCurrentIndex( SizeMap );
 970     onPhysicalMeshChanged();
 971   }
 972 }
 973
 974 /** BLSURFPluginGUI_HypothesisCreator::onRemoveEnforcedVertex()
 975 This method is called when a item is removed from the enforced verteces tree widget
 976 */
 977 void BLSURFPluginGUI_HypothesisCreator::onRemoveEnforcedVertex() {
 978 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::onRemoveEnforcedVertex");
 979   QList<QTreeWidgetItem *> selectedItems = myEnforcedTreeWidget->selectedItems();
 980   QList<QTreeWidgetItem *> selectedVerteces;
 981   QSet<QTreeWidgetItem *> selectedEntries;
 982   QTreeWidgetItem* item;
 983
 984   foreach( item, selectedItems ) {
 985     QVariant value = item->data(ENF_VER_X_COLUMN, Qt::EditRole);
 986     if (not value.isNull())
 987       selectedVerteces.append(item);
 988
 989     else
 990       selectedEntries.insert(item);
 991   }
 992
 993   foreach(item,selectedVerteces) {
 994     QTreeWidgetItem* parent = item->parent();
 995 //     MESSAGE("From geometry "<< parent->text(ENF_VER_NAME_COLUMN).toStdString()<<" remove " << item->text(ENF_VER_NAME_COLUMN).toStdString());
 996     parent->removeChild(item);
 997     delete item;
 998     if (parent->childCount() == 0) {
 999       if (selectedEntries.contains(parent))
1000         selectedEntries.remove(parent);
1001       delete parent;
1002     }
1003   }
1004
1005   foreach(item,selectedEntries) {
1006 //     MESSAGE("Remove " << item->text(ENF_VER_NAME_COLUMN).toStdString());
1007     delete item;
1008   }
1009
1010   myEnforcedTreeWidget->selectionModel()->clearSelection();
1011 }
1012
1013 /** BLSURFPluginGUI_HypothesisCreator::retrieveParams()
1014 This method updates the GUI widgets with the hypothesis data
1015 */
1016 void BLSURFPluginGUI_HypothesisCreator::retrieveParams() const
1017 {
1018   MESSAGE("BLSURFPluginGUI_HypothesisCreator::retrieveParams");
1019   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1020
1021   BlsurfHypothesisData data;
1022   that->readParamsFromHypo( data );
1023
1024   if ( myName ) {
1025     myName->setText( data.myName );
1026     QFontMetrics metrics( myName->font() );
1027     myName->setMinimumWidth( metrics.width( data.myName )+5 );
1028   }
1029   myTopology->setCurrentIndex( data.myTopology );
1030   myPhysicalMesh->setCurrentIndex( data.myPhysicalMesh );
1031   myPhySize->setText( data.myPhySize );
1032 #ifdef WITH_SIZE_BOUNDARIES
1033   myPhyMin->setText( data.myPhyMin );
1034   myPhyMax->setText( data.myPhyMax );
1035   myGeoMin->setText( data.myGeoMin );
1036   myGeoMax->setText( data.myGeoMax );
1037 #endif
1038   myGeometricMesh->setCurrentIndex( data.myGeometricMesh );
1039   myAngleMeshS->setValue( data.myAngleMeshS );
1040   myAngleMeshC->setValue( data.myAngleMeshC );
1041   myGradation->setValue( data.myGradation );
1042   myAllowQuadrangles->setChecked( data.myAllowQuadrangles );
1043   myDecimesh->setChecked( data.myDecimesh );
1044   myVerbosity->setValue( data.myVerbosity );
1045
1046   if ( myOptions.operator->() ) {
1047 //     MESSAGE("retrieveParams():myOptions->length() = " << myOptions->length());
1048     for ( int i = 0, nb = myOptions->length(); i < nb; ++i ) {
1049       QString option = that->myOptions[i].in();
1050       QStringList name_value = option.split( ":", QString::KeepEmptyParts );
1051       if ( name_value.count() > 1 ) {
1052         QString idStr = QString("%1").arg( i );
1053         int row = myOptionTable->rowCount();
1054         myOptionTable->setRowCount( row+1 );
1055         myOptionTable->setItem( row, OPTION_ID_COLUMN, new QTableWidgetItem( idStr ) );
1056         myOptionTable->item( row, OPTION_ID_COLUMN )->setFlags( 0 );
1057         myOptionTable->setItem( row, OPTION_NAME_COLUMN, new QTableWidgetItem( name_value[0] ) );
1058         myOptionTable->item( row, OPTION_NAME_COLUMN )->setFlags( 0 );
1059         myOptionTable->setItem( row, OPTION_VALUE_COLUMN, new QTableWidgetItem( name_value[1] ) );
1060         myOptionTable->item( row, OPTION_VALUE_COLUMN )->setFlags( Qt::ItemIsSelectable |
1061                                                                   Qt::ItemIsEditable   |
1062                                                                   Qt::ItemIsEnabled );
1063       }
1064     }
1065   }
1066   myOptionTable->resizeColumnToContents( OPTION_NAME_COLUMN );
1067
1068   // Sizemaps
1069 //   MESSAGE("retrieveParams():that->mySMPMap.size() = " << that->mySMPMap.size());
1070   QMapIterator<QString, QString> i(that->mySMPMap);
1071   GeomSelectionTools* myGeomToolSelected = that->getGeomSelectionTool();
1072   while (i.hasNext()) {
1073     i.next();
1074     const QString entry = i.key();
1075     string shapeName = myGeomToolSelected->getNameFromEntry(entry.toStdString());
1076     const QString sizeMap = i.value();
1077     int row = mySizeMapTable->rowCount();
1078     mySizeMapTable->setRowCount( row+1 );
1079     mySizeMapTable->setItem( row, SMP_ENTRY_COLUMN, new QTableWidgetItem( entry ) );
1080     mySizeMapTable->item( row, SMP_ENTRY_COLUMN )->setFlags( 0 );
1081     mySizeMapTable->setItem( row, SMP_NAME_COLUMN, new QTableWidgetItem( QString::fromStdString(shapeName) ) );
1082     mySizeMapTable->item( row, SMP_NAME_COLUMN )->setFlags( 0 );
1083     mySizeMapTable->setItem( row, SMP_SIZEMAP_COLUMN, new QTableWidgetItem( sizeMap ) );
1084     mySizeMapTable->item( row, SMP_SIZEMAP_COLUMN )->setFlags( Qt::ItemIsSelectable |
1085                                                                Qt::ItemIsEditable   |
1086                                                                Qt::ItemIsEnabled );
1087     }
1088
1089   mySizeMapTable->resizeColumnToContents( SMP_NAME_COLUMN );
1090   mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
1091
1092   // Enforced verteces
1093 //   MESSAGE("retrieveParams(): data.enfVertMap.size() = " << data.enfVertMap.size());
1094   std::map<std::string, std::set<std::vector<double> > >::const_iterator evmIt = data.enfVertMap.begin();
1095   for ( ; evmIt != data.enfVertMap.end() ; ++evmIt) {
1096     std::string entry = (*evmIt).first;
1097     std::string shapeName = myGeomToolSelected->getNameFromEntry(entry);
1098
1099     std::set<std::vector<double> > evs;
1100     std::set<std::vector<double> >::const_iterator evsIt;
1101     try  {
1102       evs = (*evmIt).second;
1103     }
1104     catch(...) {
1105 //       MESSAGE("evs = (*evmIt)[entry]: FAIL");
1106       break;
1107     }
1108
1109     evsIt = evs.begin();
1110     for ( ; evsIt != evs.end() ; ++evsIt) {
1111       double x, y, z;
1112       x = (*evsIt)[0];
1113       y = (*evsIt)[1];
1114       z = (*evsIt)[2];
1115       that->addEnforcedVertex(entry, shapeName, x, y, z);
1116     }
1117   }
1118   for (int column = 0; column < myEnforcedTreeWidget->columnCount(); ++column)
1119     myEnforcedTreeWidget->resizeColumnToContents(column);
1120
1121   // update widgets
1122   that->onPhysicalMeshChanged();
1123   that->onGeometricMeshChanged();
1124 }
1125
1126 /** BLSURFPluginGUI_HypothesisCreator::storeParams()
1127 This method updates the hypothesis data with the GUI widgets content.
1128 */
1129 QString BLSURFPluginGUI_HypothesisCreator::storeParams() const
1130 {
1131   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1132
1133   BlsurfHypothesisData data;
1134   QString guiHyp = that->readParamsFromWidgets( data );
1135   that->storeParamsToHypo( data );
1136
1137   return guiHyp;
1138 }
1139
1140 /** BLSURFPluginGUI_HypothesisCreator::readParamsFromHypo(h_data)
1141 Updates the hypothesis data from hypothesis values.
1142 */
1143 bool BLSURFPluginGUI_HypothesisCreator::readParamsFromHypo( BlsurfHypothesisData& h_data ) const
1144 {
1145   MESSAGE("BLSURFPluginGUI_HypothesisCreator::readParamsFromHypo");
1146   BLSURFPlugin::BLSURFPlugin_Hypothesis_var h =
1147     BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis() );
1148
1149   HypothesisData* data = SMESH::GetHypothesisData( hypType() );
1150   h_data.myName = isCreation() && data ? hypName() : "";
1151
1152   h_data.myTopology         = (int) h->GetTopology();
1153   h_data.myPhysicalMesh     = (int) h->GetPhysicalMesh();
1154   h_data.myPhySize          = QString::number( h->GetPhySize() );
1155   h_data.myGeometricMesh    = (int) h->GetGeometricMesh();
1156   h_data.myAngleMeshS       = h->GetAngleMeshS();
1157   h_data.myAngleMeshC       = h->GetAngleMeshC();
1158   h_data.myGradation        = h->GetGradation();
1159   h_data.myAllowQuadrangles = h->GetQuadAllowed();
1160   h_data.myDecimesh         = h->GetDecimesh();
1161   h_data.myVerbosity        = h->GetVerbosity();
1162
1163 #ifdef WITH_SIZE_BOUNDARIES
1164   double PhyMin = h->GetPhyMin();
1165   double PhyMax = h->GetPhyMax();
1166   double GeoMin = h->GetGeoMin();
1167   double GeoMax = h->GetGeoMax();
1168   if ( PhyMin > 0 )
1169   h_data.myPhyMin = PhyMin > 0 ? QString::number( h->GetPhyMin() ) : QString("");
1170   h_data.myPhyMax = PhyMax > 0 ? QString::number( h->GetPhyMax() ) : QString("");
1171   h_data.myGeoMin = GeoMin > 0 ? QString::number( h->GetGeoMin() ) : QString("");
1172   h_data.myGeoMax = GeoMax > 0 ? QString::number( h->GetGeoMax() ) : QString("");
1173 #endif
1174
1175   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1176   that->myOptions = h->GetOptionValues();
1177
1178   that->mySMPMap.clear();
1179
1180   // classic size maps
1181   BLSURFPlugin::string_array_var mySizeMaps = h->GetSizeMapEntries();
1182 //   MESSAGE("mySizeMaps->length() = " << mySizeMaps->length());
1183   QString fullSizeMaps;
1184   QStringList fullSizeMapList;
1185   GeomSelectionTools* myGeomToolSelected = that->getGeomSelectionTool();
1186   for ( int i = 0;i<mySizeMaps->length(); ++i ) {
1187     fullSizeMaps =  mySizeMaps[i].in();
1188 //     MESSAGE("fullSizeMaps: " << fullSizeMaps.toStdString());
1189     fullSizeMapList = fullSizeMaps.split( "|", QString::KeepEmptyParts );
1190     if ( fullSizeMapList.count() > 1 ) {
1191       string fullSizeMap = fullSizeMapList[1].toStdString();
1192       int pos = fullSizeMap.find("return")+7;
1193 //       MESSAGE("pos:" << pos);
1194       QString sizeMap;
1195       try {
1196         sizeMap = QString::fromStdString(fullSizeMap.substr(pos, fullSizeMap.size()-pos));
1197       }
1198       catch (...) {
1199         continue;
1200       }
1201       that->mySMPMap[fullSizeMapList[0]] = sizeMap;
1202 //       MESSAGE("mySMPMap[" << fullSizeMapList[0].toStdString() << "] = " << sizeMap.toStdString());
1203       that->mySMPShapeTypeMap[fullSizeMapList[0]] = myGeomToolSelected->entryToShapeType(fullSizeMapList[0].toStdString());
1204 //       MESSAGE("mySMPShapeTypeMap[" << fullSizeMapList[0].toStdString() << "] = " << that->mySMPShapeTypeMap[fullSizeMapList[0]]);
1205     }
1206   }
1207
1208   // custom size maps
1209 /*
1210   BLSURFPlugin::string_array_var myCustomSizeMaps = h->GetCustomSizeMapEntries();
1211   MESSAGE("myCustomSizeMaps->length() = " << myCustomSizeMaps->length());
1212
1213   for ( int i = 0;i<myCustomSizeMaps->length(); ++i ) {
1214     QString fullCustomSizeMaps =  myCustomSizeMaps[i].in();
1215     QStringList fullCustomSizeMapList = fullCustomSizeMaps.split( "|", QString::KeepEmptyParts );
1216     if ( fullCustomSizeMapList.count() > 1 ) {
1217       that->mySMPMap[fullCustomSizeMapList[0]] = fullCustomSizeMapList[1];
1218       that->mySMPShapeTypeMap[fullCustomSizeMapList[0]] = GeomToolSelected->entryToShapeType(fullCustomSizeMapList[0].toStdString());
1219       MESSAGE("mySMPMap[" << fullCustomSizeMapList[0].toStdString() << "] = " << fullCustomSizeMapList[1].toStdString());
1220       MESSAGE("mySMPShapeTypeMap[" << fullCustomSizeMapList[0].toStdString() << "] = " << that->mySMPShapeTypeMap[fullCustomSizeMapList[0]]);
1221     }
1222   }
1223 */
1224   // attractor
1225   BLSURFPlugin::string_array_var allMyAttractors = h->GetAttractorEntries();
1226 //   MESSAGE("myAttractors->length() = " << allMyAttractors->length());
1227
1228   for ( int i = 0;i<allMyAttractors->length(); ++i ) {
1229     QString myAttractors =  allMyAttractors[i].in();
1230     QStringList myAttractorList = myAttractors.split( "|", QString::KeepEmptyParts );
1231     if ( myAttractorList.count() > 1 ) {
1232       that->mySMPMap[myAttractorList[0]] = myAttractorList[1];
1233       that->mySMPShapeTypeMap[myAttractorList[0]] = myGeomToolSelected->entryToShapeType(myAttractorList[0].toStdString());
1234 //       MESSAGE("mySMPMap[" << myAttractorList[0].toStdString() << "] = " << myAttractorList[1].toStdString());
1235 //       MESSAGE("mySMPShapeTypeMap[" << myAttractorList[0].toStdString() << "] = " << that->mySMPShapeTypeMap[myAttractorList[0]]);
1236     }
1237   }
1238
1239   // Enforced verteces
1240   BLSURFPlugin::TEnforcedVertexMap_var enforcedVertexMap = h->GetAllEnforcedVerteces();
1241 //   MESSAGE("enforcedVertexMap->length() = " << enforcedVertexMap->length());
1242
1243   for ( int i = 0;i<enforcedVertexMap->length(); ++i ) {
1244     std::string entry =  enforcedVertexMap[i].entry.in();
1245 //     BLSURFPlugin::TEnforcedVertexList_var vertexList = enforcedVertexMap[i].vertexList;
1246     BLSURFPlugin::TEnforcedVertexList vertexList = enforcedVertexMap[i].vertexList;
1247     std::set<std::vector<double> > evs;
1248     for (int j=0 ; j<vertexList.length(); ++j) {
1249       double x = vertexList[j][0];
1250       double y = vertexList[j][1];
1251       double z = vertexList[j][2];
1252       std::vector<double> ev;
1253       ev.push_back(x);
1254       ev.push_back(y);
1255       ev.push_back(z);
1256       evs.insert(ev);
1257 //       MESSAGE("New enf vertex for entry " << entry << ": " << x << ", " << y << ", " << z);
1258     }
1259     h_data.enfVertMap[entry] = evs;
1260     if (evs.size() == 0) {
1261 //       MESSAGE("No enf vertex for entry " << entry << ": key is erased");
1262       h_data.enfVertMap.erase(entry);
1263     }
1264   }
1265
1266   return true;
1267 }
1268
1269 /** BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo(h_data)
1270 Saves the hypothesis data to hypothesis values.
1271 */
1272 bool BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo( const BlsurfHypothesisData& h_data ) const
1273 {
1274   MESSAGE("BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo");
1275   BLSURFPlugin::BLSURFPlugin_Hypothesis_var h =
1276     BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( hypothesis() );
1277
1278   bool ok = true;
1279   try
1280   {
1281     if( isCreation() )
1282       SMESH::SetName( SMESH::FindSObject( h ), h_data.myName.toLatin1().constData() );
1283
1284     if ( h->GetTopology() != h_data.myTopology ) // avoid duplication of DumpPython commands
1285       h->SetTopology( (int) h_data.myTopology );
1286     if ( h->GetPhysicalMesh() != h_data.myPhysicalMesh )
1287       h->SetPhysicalMesh( (int) h_data.myPhysicalMesh );
1288     if ( h->GetGeometricMesh() != (int) h_data.myGeometricMesh )
1289       h->SetGeometricMesh( (int) h_data.myGeometricMesh );
1290     if ( h->GetGradation() !=  h_data.myGradation )
1291       h->SetGradation( h_data.myGradation );
1292     if ( h->GetQuadAllowed() != h_data.myAllowQuadrangles )
1293       h->SetQuadAllowed( h_data.myAllowQuadrangles );
1294     if ( h->GetDecimesh() != h_data.myDecimesh )
1295       h->SetDecimesh( h_data.myDecimesh );
1296     if ( h->GetVerbosity() != h_data.myVerbosity )
1297       h->SetVerbosity( h_data.myVerbosity );
1298
1299     if( ((int) h_data.myPhysicalMesh == PhysicalUserDefined)||((int) h_data.myPhysicalMesh == SizeMap) ) {
1300       if ( h->GetPhySize() != h_data.myPhySize.toDouble() )
1301         h->SetPhySize( h_data.myPhySize.toDouble() );
1302     }
1303     if( (int) h_data.myGeometricMesh == UserDefined ) {
1304       if ( h->GetAngleMeshS() != h_data.myAngleMeshS )
1305         h->SetAngleMeshS( h_data.myAngleMeshS );
1306       if ( h->GetAngleMeshC() != h_data.myAngleMeshC )
1307         h->SetAngleMeshC( h_data.myAngleMeshC );
1308     }
1309 #ifdef WITH_SIZE_BOUNDARIES
1310     if ( !isDouble( h_data.myPhyMin ))
1311       h->SetPhyMin( -1 );
1312     else if ( h->GetPhyMin() != h_data.myPhyMin.toDouble() )
1313       h->SetPhyMin( h_data.myPhyMin.toDouble() );
1314     if ( !isDouble( h_data.myPhyMax ))
1315       h->SetPhyMax( -1 );
1316     else if ( h->GetPhyMax() != h_data.myPhyMax.toDouble() )
1317       h->SetPhyMax( h_data.myPhyMax.toDouble() );
1318     if ( !isDouble( h_data.myGeoMin ))
1319       h->SetGeoMin( -1 );
1320     else if ( h->GetGeoMin() != h_data.myGeoMin.toDouble() )
1321       h->SetGeoMin( h_data.myGeoMin.toDouble() );
1322     if ( !isDouble( h_data.myGeoMax ))
1323       h->SetGeoMax( -1 );
1324     else if ( h->GetGeoMax() != h_data.myGeoMax.toDouble() )
1325       h->SetGeoMax( h_data.myGeoMax.toDouble() );
1326 #endif
1327
1328     //printf("storeParamsToHypo():myOptions->length()=%d\n",myOptions->length());
1329     h->SetOptionValues( myOptions ); // is set in checkParams()
1330
1331     BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1332     QMapIterator<QString,QString> i(that->mySMPMap);
1333     // Iterate over each size map
1334     while (i.hasNext()) {
1335       i.next();
1336       const QString entry = i.key();
1337       const QString sizeMap = i.value();
1338
1339       if (sizeMap == "__TO_DELETE__") {
1340 //         MESSAGE("Delete entry " << entry.toStdString() << " from engine");
1341         h->UnsetEntry(entry.toLatin1().constData());
1342       }
1343       else if (sizeMap.startsWith("ATTRACTOR")) {
1344 //         MESSAGE("SetAttractorEntry(" << entry.toStdString() << ")= " << sizeMap.toStdString());
1345         h->SetAttractorEntry( entry.toLatin1().constData(), sizeMap.toLatin1().constData() );
1346       }
1347       else if (sizeMap.startsWith("def")) {
1348 //         MESSAGE("SetCustomSizeMapEntry(" << entry.toStdString() << ")= " << sizeMap.toStdString());
1349 //        h->SetCustomSizeMapEntry( entry.toLatin1().constData(), sizeMap.toLatin1().constData() );
1350       }
1351       else {
1352         QString fullSizeMap;
1353         fullSizeMap = QString("");
1354         if (that->mySMPShapeTypeMap[entry]  == TopAbs_FACE)
1355           fullSizeMap = QString("def f(u,v): return ") + sizeMap;
1356         else if (that->mySMPShapeTypeMap[entry]  == TopAbs_EDGE)
1357           fullSizeMap = QString("def f(t): return ") + sizeMap;
1358         else if (that->mySMPShapeTypeMap[entry] == TopAbs_VERTEX)
1359           fullSizeMap = QString("def f(): return ") + sizeMap;
1360
1361 //         MESSAGE("SetSizeMapEntry("<<entry.toStdString()<<") = " <<fullSizeMap.toStdString());
1362         h->SetSizeMapEntry( entry.toLatin1().constData(), fullSizeMap.toLatin1().constData() );
1363       }
1364     }
1365
1366     // Enforced verteces
1367     std::map<std::string, std::set<std::vector<double> > >::const_iterator evmIt = h_data.enfVertMap.begin();
1368     for ( ; evmIt != h_data.enfVertMap.end() ; ++evmIt) {
1369       std::string entry = evmIt->first;
1370       std::set<std::vector<double> > evs;
1371       std::set<std::vector<double> >::const_iterator evsIt;
1372       double x, y, z;
1373       BLSURFPlugin::TEnforcedVertexList_var hypVertexList;
1374       int hypNbVertex = 0;
1375       try {
1376         hypVertexList = h->GetEnforcedVertecesEntry(entry.c_str());
1377         hypNbVertex = hypVertexList->length();
1378       }
1379       catch(...) {
1380       }
1381       evs = evmIt->second;
1382       evsIt = evs.begin();
1383       for ( ; evsIt != evs.end() ; ++evsIt) {
1384         x = (*evsIt)[0];
1385         y = (*evsIt)[1];
1386         z = (*evsIt)[2];
1387 //         MESSAGE("SetEnforcedVertexEntry("<<entry<<", "<<x<<", "<<y<<", "<<z<<")");
1388         h->SetEnforcedVertexEntry( entry.c_str(), x, y, z );
1389       }
1390       // Remove old verteces
1391       if (hypNbVertex >0) {
1392         for (int i =0 ; i<hypNbVertex ; i++) {
1393           x = hypVertexList[i][0];
1394           y = hypVertexList[i][1];
1395           z = hypVertexList[i][2];
1396           std::vector<double> vertex;
1397           vertex.push_back(x);
1398           vertex.push_back(y);
1399           vertex.push_back(z);
1400           if (evs.find(vertex) == evs.end()) {
1401 //             MESSAGE("UnsetEnforcedVertexEntry("<<entry<<", "<<x<<", "<<y<<", "<<z<<")");
1402             h->UnsetEnforcedVertexEntry( entry.c_str(), x, y, z );
1403           }
1404         }
1405       }
1406     }
1407   }
1408   catch(const SALOME::SALOME_Exception& ex)
1409   {
1410     SalomeApp_Tools::QtCatchCorbaException(ex);
1411     ok = false;
1412   }
1413   return ok;
1414 }
1415
1416 /** BLSURFPluginGUI_HypothesisCreator::readParamsFromWidgets(h_data)
1417 Stores the widgets content to the hypothesis data.
1418 */
1419 QString BLSURFPluginGUI_HypothesisCreator::readParamsFromWidgets( BlsurfHypothesisData& h_data ) const
1420 {
1421   MESSAGE("BLSURFPluginGUI_HypothesisCreator::readParamsFromWidgets");
1422   h_data.myName             = myName ? myName->text() : "";
1423   h_data.myTopology         = myTopology->currentIndex();
1424   h_data.myPhysicalMesh     = myPhysicalMesh->currentIndex();
1425   h_data.myPhySize          = myPhySize->text();
1426 #ifdef WITH_SIZE_BOUNDARIES
1427   h_data.myPhyMin           = myPhyMin->text();
1428   h_data.myPhyMax           = myPhyMax->text();
1429   h_data.myGeoMin           = myGeoMin->text();
1430   h_data.myGeoMax           = myGeoMax->text();
1431 #endif
1432   h_data.myGeometricMesh    = myGeometricMesh->currentIndex();
1433   h_data.myAngleMeshS       = myAngleMeshS->value();
1434   h_data.myAngleMeshC       = myAngleMeshC->value();
1435   h_data.myGradation        = myGradation->value();
1436   h_data.myAllowQuadrangles = myAllowQuadrangles->isChecked();
1437   h_data.myDecimesh         = myDecimesh->isChecked();
1438   h_data.myVerbosity        = myVerbosity->value();
1439
1440   QString guiHyp;
1441   guiHyp += tr("BLSURF_TOPOLOGY") + " = " + QString::number( h_data.myTopology ) + "; ";
1442   guiHyp += tr("BLSURF_PHY_MESH") + " = " + QString::number( h_data.myPhysicalMesh ) + "; ";
1443   guiHyp += tr("BLSURF_HPHYDEF") + " = " + h_data.myPhySize + "; ";
1444   guiHyp += tr("BLSURF_GEOM_MESH") + " = " + QString::number( h_data.myGeometricMesh ) + "; ";
1445   guiHyp += tr("BLSURF_ANGLE_MESH_S") + " = " + QString::number( h_data.myAngleMeshS ) + "; ";
1446   guiHyp += tr("BLSURF_GRADATION") + " = " + QString::number( h_data.myGradation ) + "; ";
1447   guiHyp += tr("BLSURF_ALLOW_QUADRANGLES") + " = " + QString(h_data.myAllowQuadrangles ? "yes" : "no") + "; ";
1448   guiHyp += tr("BLSURF_DECIMESH") + " = " + QString(h_data.myDecimesh ? "yes" : "no") + "; ";
1449 #ifdef WITH_SIZE_BOUNDARIES
1450   if ( isDouble( h_data.myPhyMin )) guiHyp += "hphymin = " + h_data.myPhyMin + "; ";
1451   if ( isDouble( h_data.myPhyMax )) guiHyp += "hphymax = " + h_data.myPhyMax + "; ";
1452   if ( isDouble( h_data.myGeoMin )) guiHyp += "hgeomin = " + h_data.myGeoMin + "; ";
1453   if ( isDouble( h_data.myGeoMax )) guiHyp += "hgeomax = " + h_data.myGeoMax + "; ";
1454 #endif
1455
1456   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1457   int row = 0, nbRows = myOptionTable->rowCount();
1458   for ( ; row < nbRows; ++row )
1459   {
1460     int id = myOptionTable->item( row, OPTION_ID_COLUMN )->text().toInt();
1461     if ( id >= 0 && id < myOptions->length() )
1462     {
1463       QString name  = myOptionTable->item( row, OPTION_NAME_COLUMN )->text();
1464       QString value = myOptionTable->item( row, OPTION_VALUE_COLUMN )->text().trimmed();
1465       if ( value.isNull() )
1466         value = "";
1467       that->myOptions[ id ] = ( name + ":" + value).toLatin1().constData();
1468       if ( value != "" )
1469         guiHyp += name + " = " + value + "; ";
1470     }
1471   }
1472
1473   // SizeMap
1474   row = 0, nbRows = mySizeMapTable->rowCount();
1475   for ( ; row < nbRows; ++row )
1476   {
1477       QString entry   = mySizeMapTable->item( row, SMP_ENTRY_COLUMN )->text();
1478       if ( that->mySMPMap.contains(entry) )
1479         guiHyp += "SetSizeMapEntry(" + entry + ", " + that->mySMPMap[entry] + "); ";
1480   }
1481
1482   // Enforced verteces
1483   // h_data.enfVertMap
1484
1485   int nbEnforcedShapes = myEnforcedTreeWidget->topLevelItemCount();
1486   int nbEnforcedVerteces = 0;
1487 //   MESSAGE("Nb of enforced shapes: " << nbEnforcedShapes);
1488   for (int i=0 ; i<nbEnforcedShapes ; i++) {
1489     QTreeWidgetItem* shapeItem = myEnforcedTreeWidget->topLevelItem(i);
1490     if (shapeItem) {
1491       std::string entry = shapeItem->data(ENF_VER_ENTRY_COLUMN,Qt::EditRole).toString().toStdString();
1492       nbEnforcedVerteces = shapeItem->childCount();
1493       if (nbEnforcedVerteces >0) {
1494         double childValueX,childValueY,childValueZ;
1495         QTreeWidgetItem* child;
1496         std::set<std::vector<double> > evs;
1497         for (row = 0;row<nbEnforcedVerteces;row++) {
1498           child = shapeItem->child(row);
1499           childValueX = child->data(ENF_VER_X_COLUMN,Qt::EditRole).toDouble();
1500           childValueY = child->data(ENF_VER_Y_COLUMN,Qt::EditRole).toDouble();
1501           childValueZ = child->data(ENF_VER_Z_COLUMN,Qt::EditRole).toDouble();
1502           std::vector<double> vertex;
1503           vertex.push_back(childValueX);
1504           vertex.push_back(childValueY);
1505           vertex.push_back(childValueZ);
1506           evs.insert(vertex);
1507         }
1508         h_data.enfVertMap[entry] = evs;
1509       }
1510     }
1511   }
1512
1513   MESSAGE("guiHyp : " << guiHyp.toLatin1().data());
1514   return guiHyp;
1515 }
1516
1517 void BLSURFPluginGUI_HypothesisCreator::onPhysicalMeshChanged() {
1518   MESSAGE("BLSURFPluginGUI_HypothesisCreator::onPhysicalMeshChanged");
1519   bool isPhysicalUserDefined = (myPhysicalMesh->currentIndex() == PhysicalUserDefined);
1520   bool isSizeMap = (myPhysicalMesh->currentIndex() == SizeMap);
1521   bool isCustom = (isPhysicalUserDefined || isSizeMap) ;
1522   bool geomIsCustom = (myGeometricMesh->currentIndex() == UserDefined);
1523
1524   myGradation->setEnabled(not isPhysicalUserDefined || geomIsCustom);
1525   myPhySize->setEnabled(isCustom);
1526   myPhyMax->setEnabled(isCustom);
1527   myPhyMin->setEnabled(isCustom);
1528
1529   if ( !isSizeMap) {
1530     double gradation;
1531     switch( myPhysicalMesh->currentIndex() ) {
1532       case DefaultSize:
1533       default:
1534         gradation = 1.1;
1535         break;
1536     }
1537     myGradation->setValue( gradation );
1538   }
1539
1540   if ( !isCustom ) {
1541     QString aPhySize = "";
1542     switch( myPhysicalMesh->currentIndex() ) {
1543       case DefaultSize:
1544       default:
1545         aPhySize = "10";
1546         break;
1547       }
1548     myPhySize->setText( aPhySize );
1549     if ( !isDouble( myPhyMin->text(), true ))
1550       myPhyMin->setText("");
1551     if ( !isDouble( myPhyMax->text(), true ))
1552       myPhyMax->setText("");
1553     if ( myGeometricMesh->currentIndex() == DefaultGeom ) {
1554       myGeometricMesh->setCurrentIndex( UserDefined );
1555       onGeometricMeshChanged();
1556     }
1557   }
1558 }
1559
1560 void BLSURFPluginGUI_HypothesisCreator::onGeometricMeshChanged() {
1561   MESSAGE("BLSURFPluginGUI_HypothesisCreator::onGeometricMeshChanged");
1562   bool isCustom = (myGeometricMesh->currentIndex() == UserDefined);
1563   bool phyIsSizemap = (myPhysicalMesh->currentIndex() == SizeMap);
1564
1565   myAngleMeshS->setEnabled(isCustom);
1566   myAngleMeshC->setEnabled(isCustom);
1567   myGradation->setEnabled(isCustom || phyIsSizemap);
1568   myGeoMax->setEnabled(isCustom);
1569   myGeoMin->setEnabled(isCustom);
1570
1571   if ( ! isCustom ) {
1572     double aAngleMeshS;
1573     switch( myGeometricMesh->currentIndex() ) {
1574       case DefaultGeom:
1575       default:
1576         aAngleMeshS = 8;
1577         break;
1578       }
1579     myAngleMeshS->setValue( aAngleMeshS );
1580     myAngleMeshC->setValue( aAngleMeshS );
1581     if ( !isDouble( myGeoMin->text(), true ))
1582       myGeoMin->setText("");
1583     if ( !isDouble( myGeoMax->text(), true ))
1584       myGeoMax->setText("");
1585     //  hphy_flag = 0 and hgeo_flag = 0 is not allowed (spec)
1586     if ( myPhysicalMesh->currentIndex() == DefaultSize ) {
1587       myPhysicalMesh->setCurrentIndex( PhysicalUserDefined );
1588       onPhysicalMeshChanged();
1589     }
1590   }
1591 }
1592
1593 void BLSURFPluginGUI_HypothesisCreator::onAddOption()
1594 {
1595   QMenu* menu = (QMenu*)sender();
1596   // fill popup with option names
1597   menu->clear();
1598   if ( myOptions.operator->() ) {
1599     for ( int i = 0, nb = myOptions->length(); i < nb; ++i ) {
1600       QString name_value = myOptions[i].in();
1601       QString name = name_value.split( ":", QString::KeepEmptyParts )[0];
1602       menu->addAction( name );
1603     }
1604   }
1605 }
1606
1607 void BLSURFPluginGUI_HypothesisCreator::onOptionChosenInPopup( QAction* a )
1608 {
1609   myOptionTable->setFocus();
1610   QMenu* menu = (QMenu*)( a->parent() );
1611
1612   int idx = menu->actions().indexOf( a );
1613   QString idStr = QString("%1").arg( idx );
1614   QString option = myOptions[idx].in();
1615   QString optionName = option.split( ":", QString::KeepEmptyParts )[0];
1616
1617   // look for a row with optionName
1618   int row = 0, nbRows = myOptionTable->rowCount();
1619   for ( ; row < nbRows; ++row )
1620     if ( myOptionTable->item( row, OPTION_ID_COLUMN )->text() == idStr )
1621       break;
1622   // add a row if not found
1623   if ( row == nbRows ) {
1624     myOptionTable->setRowCount( row+1 );
1625     myOptionTable->setItem( row, OPTION_ID_COLUMN, new QTableWidgetItem( idStr ) );
1626     myOptionTable->item( row, OPTION_ID_COLUMN )->setFlags( 0 );
1627     myOptionTable->setItem( row, OPTION_NAME_COLUMN, new QTableWidgetItem( optionName ) );
1628     myOptionTable->item( row, OPTION_NAME_COLUMN )->setFlags( 0 );
1629     myOptionTable->setItem( row, OPTION_VALUE_COLUMN, new QTableWidgetItem( "" ) );
1630     myOptionTable->item( row, OPTION_VALUE_COLUMN )->setFlags( Qt::ItemIsSelectable |
1631                                                                Qt::ItemIsEditable   |
1632                                                                Qt::ItemIsEnabled );
1633     myOptionTable->resizeColumnToContents( OPTION_NAME_COLUMN );
1634   }
1635   myOptionTable->clearSelection();
1636   myOptionTable->scrollToItem( myOptionTable->item( row, OPTION_VALUE_COLUMN ) );
1637   //myOptionTable->item( row, OPTION_VALUE_COLUMN )->setSelected( true );
1638   myOptionTable->setCurrentCell( row, OPTION_VALUE_COLUMN );
1639   //myOptionTable->openPersistentEditor( myOptionTable->item( row, OPTION_VALUE_COLUMN ) );
1640 }
1641
1642 void BLSURFPluginGUI_HypothesisCreator::onDeleteOption()
1643 {
1644   // clear option values and remember selected row
1645   QList<int> selectedRows;
1646   QList<QTableWidgetItem*> selected = myOptionTable->selectedItems();
1647   QTableWidgetItem* item;
1648   foreach( item, selected ) {
1649     int row = item->row();
1650     if ( !selectedRows.contains( row ) ) {
1651       selectedRows.append( row );
1652       int id = myOptionTable->item( row, OPTION_ID_COLUMN )->text().toInt();
1653       if ( id >= 0 && id < myOptions->length() )
1654         myOptions[ id ] = myOptionTable->item( row, OPTION_NAME_COLUMN )->text().toLatin1().constData();
1655     }
1656   }
1657   qSort( selectedRows );
1658   QListIterator<int> it( selectedRows );
1659   it.toBack();
1660   while ( it.hasPrevious() )
1661     myOptionTable->removeRow( it.previous() );
1662 }
1663
1664 // **********************
1665 // *** BEGIN SIZE MAP ***
1666 // **********************
1667
1668
1669 void BLSURFPluginGUI_HypothesisCreator::onRemoveMap()
1670 {
1671   MESSAGE("BLSURFPluginGUI_HypothesisCreator::onRemoveMap()");
1672   QList<int> selectedRows;
1673   QList<QTableWidgetItem*> selected = mySizeMapTable->selectedItems();
1674   QTableWidgetItem* item;
1675   int row;
1676   foreach( item, selected ) {
1677     row = item->row();
1678     if ( !selectedRows.contains( row ) )
1679       selectedRows.append( row );
1680   }
1681
1682   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1683
1684   qSort( selectedRows );
1685   QListIterator<int> it( selectedRows );
1686   it.toBack();
1687   while ( it.hasPrevious() ) {
1688       row = it.previous();
1689       QString entry = mySizeMapTable->item(row,SMP_ENTRY_COLUMN)->text();
1690       if (that->mySMPMap.contains(entry))
1691         that->mySMPMap[entry] = "__TO_DELETE__";
1692       if (that->mySMPShapeTypeMap.contains(entry))
1693         that->mySMPShapeTypeMap.remove(entry);
1694       mySizeMapTable->removeRow(row );
1695   }
1696   mySizeMapTable->resizeColumnToContents(SMP_NAME_COLUMN);
1697   mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
1698 }
1699
1700 void BLSURFPluginGUI_HypothesisCreator::onSetSizeMap(int row,int col)
1701 {
1702   MESSAGE("BLSURFPluginGUI_HypothesisCreator::onSetSizeMap("<< row << "," << col << ")");
1703   if (col == SMP_SIZEMAP_COLUMN) {
1704     BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1705     QString entry   = that->mySizeMapTable->item(row, SMP_ENTRY_COLUMN)->text();
1706     QString sizeMap = that->mySizeMapTable->item(row, SMP_SIZEMAP_COLUMN)->text().trimmed();
1707 //     MESSAGE("entry: " << entry.toStdString() << ", sizeMap: " << sizeMap.toStdString());
1708     if (not that->mySMPShapeTypeMap.contains(entry))
1709       return;
1710     if (that->mySMPMap.contains(entry))
1711       if (that->mySMPMap[entry] == sizeMap)
1712         return;
1713     QColor* bgColor = new QColor("white");
1714     QColor* fgColor = new QColor("black");
1715     if (not sizeMap.isEmpty()) {
1716       that->mySMPMap[entry] = sizeMap;
1717       if (not sizeMapValidationFromRow(row)) {
1718         bgColor->setRgb(255,0,0);
1719         fgColor->setRgb(255,255,255);
1720       }
1721     }
1722     else {
1723 //       MESSAGE("Size map empty: reverse to precedent value" );
1724       that->mySizeMapTable->item(row, SMP_SIZEMAP_COLUMN)->setText(that->mySMPMap[entry]);
1725     }
1726     that->mySizeMapTable->item(row, SMP_NAME_COLUMN)->setBackground(QBrush(*bgColor));
1727     that->mySizeMapTable->item(row, SMP_SIZEMAP_COLUMN)->setBackground(QBrush(*bgColor));
1728     that->mySizeMapTable->item(row, SMP_NAME_COLUMN)->setForeground(QBrush(*fgColor));
1729     that->mySizeMapTable->item(row, SMP_SIZEMAP_COLUMN)->setForeground(QBrush(*fgColor));
1730     mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
1731   }
1732 }
1733
1734 void BLSURFPluginGUI_HypothesisCreator::onAddMapOnSurface()
1735 {
1736  insertElementType(TopAbs_FACE);
1737 }
1738
1739 void BLSURFPluginGUI_HypothesisCreator::onAddMapOnEdge()
1740 {
1741  insertElementType(TopAbs_EDGE);
1742 }
1743
1744 void BLSURFPluginGUI_HypothesisCreator::onAddMapOnPoint()
1745 {
1746  insertElementType(TopAbs_VERTEX);
1747 }
1748
1749 void BLSURFPluginGUI_HypothesisCreator::insertElementType(TopAbs_ShapeEnum typeShapeAsked)
1750 {
1751 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::insertElementType()");
1752
1753   BLSURFPlugin::BLSURFPlugin_Hypothesis_var h =
1754     BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis());
1755
1756   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1757
1758   TopAbs_ShapeEnum shapeType;
1759   string entry, shapeName;
1760   GeomSelectionTools* myGeomToolSelected = that->getGeomSelectionTool();
1761
1762   LightApp_SelectionMgr* mySel = myGeomToolSelected->selectionMgr();
1763
1764   SALOME_ListIO ListSelectedObjects;
1765   mySel->selectedObjects(ListSelectedObjects, NULL, false );
1766   if (!ListSelectedObjects.IsEmpty())
1767   {
1768     SALOME_ListIteratorOfListIO Object_It(ListSelectedObjects);
1769     for (; Object_It.More(); Object_It.Next())
1770     {
1771       Handle(SALOME_InteractiveObject) anObject = Object_It.Value();
1772       entry     = myGeomToolSelected->getEntryOfObject(anObject);
1773       shapeName = anObject->getName();
1774       shapeType         = myGeomToolSelected->entryToShapeType(entry);
1775 //       MESSAGE("Object Name = " << shapeName << "& Type is " << anObject->getComponentDataType() << " & ShapeType is " << shapeType);
1776       if (shapeType == typeShapeAsked)
1777       {
1778         mySizeMapTable->setFocus();
1779         QString shapeEntry;
1780         shapeEntry = QString::fromStdString(entry);
1781         double phySize = h->GetPhySize();
1782         std::ostringstream oss;
1783         oss << phySize;
1784         QString sizeMap;
1785         sizeMap  = QString::fromStdString(oss.str());
1786         if (that->mySMPMap.contains(shapeEntry)) {
1787           if (that->mySMPMap[shapeEntry] != "__TO_DELETE__") {
1788 //             MESSAGE("Size map for shape with name(entry): "<< shapeName << "(" << entry << ")");
1789             break;
1790           }
1791         }
1792         that->mySMPMap[shapeEntry] = sizeMap;
1793         that->mySMPShapeTypeMap[shapeEntry] = typeShapeAsked;
1794         int row = mySizeMapTable->rowCount() ;
1795         mySizeMapTable->setRowCount( row+1 );
1796         mySizeMapTable->setItem( row, SMP_ENTRY_COLUMN, new QTableWidgetItem( shapeEntry ) );
1797         mySizeMapTable->item( row, SMP_ENTRY_COLUMN )->setFlags( 0 );
1798         mySizeMapTable->setItem( row, SMP_NAME_COLUMN, new QTableWidgetItem( QString::fromStdString(shapeName) ) );
1799         mySizeMapTable->item( row, SMP_NAME_COLUMN )->setFlags( 0 );
1800         mySizeMapTable->setItem( row, SMP_SIZEMAP_COLUMN, new QTableWidgetItem( sizeMap ) );
1801         mySizeMapTable->item( row, SMP_SIZEMAP_COLUMN )->setFlags( Qt::ItemIsSelectable |Qt::ItemIsEditable   |Qt::ItemIsEnabled );
1802         mySizeMapTable->resizeColumnToContents( SMP_NAME_COLUMN );
1803         mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
1804         mySizeMapTable->clearSelection();
1805         mySizeMapTable->scrollToItem( mySizeMapTable->item( row, SMP_SIZEMAP_COLUMN ) );
1806
1807         if ( myPhysicalMesh->currentIndex() != SizeMap ) {
1808           myPhysicalMesh->setCurrentIndex( SizeMap );
1809           onPhysicalMeshChanged();
1810         }
1811       }
1812     }
1813   }
1814 }
1815
1816 bool BLSURFPluginGUI_HypothesisCreator::sizeMapsValidation()
1817 {
1818 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::sizeMapsValidation()");
1819   int row = 0, nbRows = mySizeMapTable->rowCount();
1820   for ( ; row < nbRows; ++row )
1821     if (not sizeMapValidationFromRow(row))
1822       return false;
1823   return true;
1824 }
1825
1826 bool BLSURFPluginGUI_HypothesisCreator::sizeMapValidationFromRow(int myRow, bool displayError)
1827 {
1828 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::sizeMapValidationFromRow()");
1829   QString myEntry   = mySizeMapTable->item( myRow, SMP_ENTRY_COLUMN )->text();
1830   bool res = sizeMapValidationFromEntry(myEntry,displayError);
1831   mySizeMapTable->setFocus();
1832   return res;
1833 }
1834
1835 bool BLSURFPluginGUI_HypothesisCreator::sizeMapValidationFromEntry(QString myEntry, bool displayError)
1836 {
1837 //   MESSAGE("BLSURFPluginGUI_HypothesisCreator::sizeMapValidationFromEntry()");
1838
1839   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
1840
1841   if (not that->mySMPMap.contains(myEntry)) {
1842 //     MESSAGE("Geometry with entry "<<myEntry.toStdString()<<" was not found.");
1843     return false;
1844   }
1845   if (not that->mySMPShapeTypeMap.contains(myEntry)) {
1846 //     MESSAGE("Shape type with entry "<<myEntry.toStdString()<<" was not found.");
1847     return false;
1848   }
1849
1850   string expr;
1851
1852   if (that->mySMPMap[myEntry].startsWith("def")) {
1853 //     MESSAGE("custom function" );
1854     expr = that->mySMPMap[myEntry].toStdString();
1855   }
1856   else if (that->mySMPMap[myEntry].startsWith("ATTRACTOR")) {
1857 //     MESSAGE("Attractor" );
1858     if ((that->mySMPMap[myEntry].count(QRegExp("^ATTRACTOR\\((?:(-?0(\\.\\d*)*|-?[1-9]+\\d*(\\.\\d*)*|-?\\.(\\d)+);){5}(True|False)\\)$")) != 1)) {
1859 //     if ((that->mySMPMap[myEntry].count('(') != 1) or
1860 //         (that->mySMPMap[myEntry].count(')') != 1) or
1861 //         (that->mySMPMap[myEntry].count(';') != 4) or
1862 //         (that->mySMPMap[myEntry].size() == 15)){
1863       if (displayError)
1864         SUIT_MessageBox::warning( dlg(),"Definition of attractor : Error" ,"An attractor is defined with the following pattern: ATTRACTOR(xa;ya;za;a;b;True|False)" );
1865       return false;
1866     }
1867     return true;
1868   }
1869   else {
1870     // case size map is empty
1871     if (that->mySMPMap[myEntry].isEmpty()) {
1872       if (displayError)
1873         SUIT_MessageBox::warning( dlg(),"Definition of size map : Error" , "Size map can't be empty");
1874       return false;
1875     }
1876     else {
1877       if ( that->mySMPShapeTypeMap[myEntry] == TopAbs_FACE)
1878         expr = "def f(u,v) : return " + that->mySMPMap[myEntry].toStdString();
1879       else if ( that->mySMPShapeTypeMap[myEntry] == TopAbs_EDGE)
1880         expr = "def f(t) : return " + that->mySMPMap[myEntry].toStdString();
1881       else if ( that->mySMPShapeTypeMap[myEntry] == TopAbs_VERTEX)
1882         expr = "def f() : return " + that->mySMPMap[myEntry].toStdString();
1883     }
1884   }
1885   //assert(Py_IsInitialized());
1886   if (not Py_IsInitialized())
1887     throw ("Erreur: Python interpreter is not initialized");
1888   PyGILState_STATE gstate;
1889   gstate = PyGILState_Ensure();
1890
1891   PyObject * obj = NULL;
1892   PyObject* new_stderr = NULL;
1893   string  err_description="";
1894   obj= PyRun_String(expr.c_str(), Py_file_input, main_dict, NULL);
1895   if (obj == NULL){
1896     fflush(stderr);
1897     err_description="";
1898     new_stderr=newPyStdOut(err_description);
1899     PySys_SetObject("stderr", new_stderr);
1900     PyErr_Print();
1901     PySys_SetObject("stderr", PySys_GetObject("__stderr__"));
1902     Py_DECREF(new_stderr);
1903     if (displayError)
1904       SUIT_MessageBox::warning( dlg(),"Definition of Python Function : Error" ,err_description.c_str() );
1905     PyGILState_Release(gstate);
1906     return false;
1907   }
1908   Py_DECREF(obj);
1909
1910   PyObject * func = NULL;
1911   func = PyObject_GetAttrString(main_mod, "f");
1912   if ( func == NULL){
1913     fflush(stderr);
1914     err_description="";
1915     new_stderr=newPyStdOut(err_description);
1916     PySys_SetObject("stderr", new_stderr);
1917     PyErr_Print();
1918     PySys_SetObject("stderr", PySys_GetObject("__stderr__"));
1919     Py_DECREF(new_stderr);
1920     if (displayError)
1921       SUIT_MessageBox::warning( dlg(),"Python Error" ,err_description.c_str() );
1922     PyGILState_Release(gstate);
1923     return false;
1924   }
1925
1926   PyGILState_Release(gstate);
1927
1928 //   MESSAGE("SizeMap expression "<<expr<<" is valid");
1929
1930   return true;
1931 }
1932
1933 /*
1934 void BLSURFPluginGUI_HypothesisCreator::OnEditMapFunction(QModelIndex* index) {
1935   int myRow = index->row();
1936   int myColumn = index->column();
1937
1938   if (myColumn == 2){
1939      if (!myEditor) {
1940          myEditor = new BLSURFPluginGUI_MapFunctionEditor(sizeMapModel->item(myRow,0)->text());
1941          connect(myEditor, SIGNAL(FunctionEntered(QString)), this, SLOT(FunctionLightValidation(QString)));
1942      }
1943      myEditor->exec();
1944 //      myEditor->show();
1945 //      myEditor->raise();
1946 //      myEditor->activateWindow();
1947
1948
1949 //     BLSURFPluginGUI_MapFunctionEditor* myEditor = new BLSURFPluginGUI_MapFunctionEditor(sizeMapModel->item(myRow,0)->text());
1950 //     myEditor->exec();
1951      QString myFunction = myEditor->GetFunctionText();
1952      // FIN RECUPERATION FONCTION
1953
1954      if (! myFunction.isEmpty()) {
1955
1956      // MAJ DE LA MAP
1957
1958      BLSURFPlugin::BLSURFPlugin_Hypothesis_var h =
1959        BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis());
1960
1961 //     h->SetSizeMapEntry(sizeMapModel->item(myRow,1)->text().toLatin1().constData(),
1962 //                        item->text().toLatin1().constData());
1963      h->SetSizeMapEntry(sizeMapModel->item(myRow,1)->text().toLatin1().constData(),
1964                         myFunction.toLatin1().constData());
1965      // FIN MAJ DE LA MAP
1966      }
1967   }
1968 }*/
1969
1970 QString BLSURFPluginGUI_HypothesisCreator::caption() const
1971 {
1972   return tr( "BLSURF_TITLE" );
1973 }
1974
1975 QPixmap BLSURFPluginGUI_HypothesisCreator::icon() const
1976 {
1977   return SUIT_Session::session()->resourceMgr()->loadPixmap( "BLSURFPlugin", tr( "ICON_DLG_BLSURF_PARAMETERS") );
1978 }
1979
1980 QString BLSURFPluginGUI_HypothesisCreator::type() const
1981 {
1982   return tr( "BLSURF_HYPOTHESIS" );
1983 }
1984
1985 QString BLSURFPluginGUI_HypothesisCreator::helpPage() const
1986 {
1987   return "blsurf_hypo_page.html";
1988 }
1989
1990 LightApp_SelectionMgr* BLSURFPluginGUI_HypothesisCreator::selectionMgr()
1991 {
1992
1993   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1994   if( anApp )
1995     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1996   else
1997     return 0;
1998 }
1999