src/SMESHGUI/SMESHGUI_FilterDlg.cxx

   1 //  SMESH SMESHGUI : GUI for SMESH component
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   : SMESHGUI_FilterDlg.cxx
  25 //  Author : Sergey LITONIN
  26 //  Module : SMESH
  27
  28 #include "SMESHGUI_FilterDlg.h"
  29
  30 #include "SMESHGUI.h"
  31 #include "SMESHGUI_Utils.h"
  32 #include "SMESHGUI_VTKUtils.h"
  33 #include "SMESHGUI_Filter.h"
  34 #include "SMESHGUI_FilterUtils.h"
  35 #include "SMESHGUI_FilterLibraryDlg.h"
  36
  37 #include "SMESH_Actor.h"
  38 #include "SMESH_NumberFilter.hxx"
  39 #include "SMESH_TypeFilter.hxx"
  40
  41 #include "GEOMBase.h"
  42 #include "GEOM_FaceFilter.h"
  43 #include "GEOM_TypeFilter.h"
  44
  45 #include "SUIT_Desktop.h"
  46 #include "SUIT_ResourceMgr.h"
  47 #include "SUIT_Session.h"
  48 #include "SUIT_MessageBox.h"
  49
  50 #include "LightApp_Application.h"
  51 #include "SalomeApp_Tools.h"
  52 #include "SalomeApp_Study.h"
  53
  54 #include "SALOME_ListIO.hxx"
  55 #include "SALOME_ListIteratorOfListIO.hxx"
  56 #include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx"
  57 #include "SALOMEDSClient_Study.hxx"
  58
  59 #include "SVTK_ViewWindow.h"
  60 #include "SVTK_Selector.h"
  61
  62 // OCCT Includes
  63 #include <StdSelect_TypeOfFace.hxx>
  64 #include <BRep_Tool.hxx>
  65 #include <TopoDS.hxx>
  66 #include <TopoDS_Face.hxx>
  67 #include <TopoDS_Shape.hxx>
  68 #include <Geom_Plane.hxx>
  69 #include <Geom_CylindricalSurface.hxx>
  70 #include <Precision.hxx>
  71 #include <TColStd_MapOfInteger.hxx>
  72 #include <TColStd_IndexedMapOfInteger.hxx>
  73 #include <TColStd_MapIteratorOfMapOfInteger.hxx>
  74
  75 // QT Includes
  76 #include <qframe.h>
  77 #include <qlayout.h>
  78 #include <qlineedit.h>
  79 #include <qpushbutton.h>
  80 #include <qgroupbox.h>
  81 #include <qtable.h>
  82 #include <qstringlist.h>
  83 #include <qlayout.h>
  84 #include <qwidgetstack.h>
  85 #include <qapplication.h>
  86 #include <qcombobox.h>
  87 #include <qfontmetrics.h>
  88 #include <qmessagebox.h>
  89 #include <qlabel.h>
  90 #include <qbuttongroup.h>
  91 #include <qradiobutton.h>
  92 #include <qregexp.h>
  93 #include <qlistbox.h>
  94 #include <qcheckbox.h>
  95 #include <qobjectlist.h>
  96 #include <qvalidator.h>
  97
  98 // IDL Headers
  99 #include "SALOMEconfig.h"
 100 #include CORBA_SERVER_HEADER(SMESH_Group)
 101
 102 #define SPACING 5
 103 #define MARGIN  10
 104
 105 using namespace SMESH;
 106
 107 static int maxLength (const QMap<int, QString> theMap, const QFontMetrics& theMetrics)
 108 {
 109   int aRes = 0;
 110   QMap<int, QString>::const_iterator anIter;
 111   for (anIter = theMap.begin(); anIter != theMap.end(); ++anIter)
 112     aRes = Max(aRes, theMetrics.width(anIter.data()));
 113   return aRes;
 114 }
 115
 116 static int getFilterId (SMESH::ElementType theType)
 117 {
 118   switch (theType)
 119   {
 120     case SMESH::NODE   : return SMESHGUI_NodeFilter;
 121     case SMESH::EDGE   : return SMESHGUI_EdgeFilter;
 122     case SMESH::FACE   : return SMESHGUI_FaceFilter;
 123     case SMESH::VOLUME : return SMESHGUI_VolumeFilter;
 124     case SMESH::ALL    : return SMESHGUI_AllElementsFilter;
 125     default            : return SMESHGUI_UnknownFilter;
 126   }
 127 }
 128
 129 /*
 130   Class       : SMESHGUI_FilterTable::AdditionalWidget
 131   Description : Class for storing additional parameters of criterion
 132 */
 133
 134 class SMESHGUI_FilterTable::AdditionalWidget : public QFrame
 135 {
 136 public:
 137   enum { Tolerance };
 138
 139 public:
 140
 141                           AdditionalWidget(QWidget* theParent);
 142   virtual                 ~AdditionalWidget();
 143
 144   virtual void            GetParameters(QValueList<int>&) const;
 145   virtual bool            IsValid(const bool theMsg = true) const;
 146   virtual double          GetDouble(const int theId) const;
 147   virtual int             GetInteger(const int theId) const;
 148   virtual QString         GetString(const int theId) const;
 149   virtual void            SetDouble(const int theId, const double theVal);
 150   virtual void            SetInteger(const int theId, const int theVal);
 151   virtual void            SetString(const int theId, const QString& theVal);
 152   void                    SetEditable(const int theId, const bool isEditable);
 153   void                    SetEditable(const bool isEditable);
 154
 155 private:
 156   QMap< int, QLineEdit* > myLineEdits;
 157 };
 158
 159 SMESHGUI_FilterTable::AdditionalWidget::AdditionalWidget (QWidget* theParent)
 160      : QFrame(theParent)
 161 {
 162   QLabel* aLabel = new QLabel(tr("SMESH_TOLERANCE"), this);
 163   myLineEdits[ Tolerance ] = new QLineEdit(this);
 164   QDoubleValidator* aValidator = new QDoubleValidator(myLineEdits[ Tolerance ]);
 165   aValidator->setBottom(0);
 166   myLineEdits[ Tolerance ]->setValidator(aValidator);
 167
 168   QHBoxLayout* aLay = new QHBoxLayout(this, 0, SPACING);
 169   aLay->addWidget(aLabel);
 170   aLay->addWidget(myLineEdits[ Tolerance ]);
 171
 172   QSpacerItem* aSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum);
 173   aLay->addItem(aSpacer);
 174
 175   QString aText = QString("%1").arg(Precision::Confusion());
 176   myLineEdits[ Tolerance ]->setText(aText);
 177 }
 178
 179  SMESHGUI_FilterTable::AdditionalWidget::~AdditionalWidget()
 180 {
 181 }
 182
 183 void SMESHGUI_FilterTable::AdditionalWidget::GetParameters (QValueList<int>& theList) const
 184 {
 185   theList.clear();
 186   theList.append(Tolerance);
 187 }
 188
 189 bool SMESHGUI_FilterTable::AdditionalWidget::IsValid (const bool theMsg) const
 190 {
 191   if (!isEnabled())
 192     return true;
 193
 194   QValueList<int> aParams;
 195   GetParameters(aParams);
 196   QValueList<int>::const_iterator anIter;
 197   for (anIter = aParams.begin(); anIter != aParams.end(); ++anIter) {
 198     const QLineEdit* aWg = myLineEdits[ *anIter ];
 199     int p = 0;
 200     QString aText = aWg->text();
 201     if (aWg->isEnabled() && aWg->validator()->validate(aText, p) != QValidator::Acceptable) {
 202       if (theMsg)
 203         QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
 204                                  tr("SMESHGUI_INVALID_PARAMETERS"), QMessageBox::Ok);
 205       return false;
 206     }
 207   }
 208
 209   return true;
 210 }
 211
 212 double SMESHGUI_FilterTable::AdditionalWidget::GetDouble (const int theId) const
 213 {
 214   return myLineEdits.contains(theId) ? myLineEdits[ theId ]->text().toDouble() : 0;
 215 }
 216
 217 int SMESHGUI_FilterTable::AdditionalWidget::GetInteger (const int theId) const
 218 {
 219   return myLineEdits.contains(theId) ? myLineEdits[ theId ]->text().toInt() : 0;
 220 }
 221
 222 QString SMESHGUI_FilterTable::AdditionalWidget::GetString (const int theId) const
 223 {
 224   return myLineEdits.contains(theId) ? myLineEdits[ theId ]->text() : QString("");
 225 }
 226
 227 void SMESHGUI_FilterTable::AdditionalWidget::SetDouble (const int theId, const double theVal)
 228 {
 229   if (myLineEdits.contains(theId))
 230     myLineEdits[ theId ]->setText(QString("%1").arg(theVal));
 231 }
 232
 233 void SMESHGUI_FilterTable::AdditionalWidget::SetInteger (const int theId, const int theVal)
 234 {
 235   if (myLineEdits.contains(theId))
 236     myLineEdits[ theId ]->setText(QString("%1").arg(theVal));
 237 }
 238
 239 void SMESHGUI_FilterTable::AdditionalWidget::SetString (const int theId, const QString& theVal)
 240 {
 241   if (myLineEdits.contains(theId))
 242     myLineEdits[ theId ]->setText(theVal);
 243 }
 244
 245 void SMESHGUI_FilterTable::AdditionalWidget::SetEditable (const int theId, const bool isEditable)
 246 {
 247   if (myLineEdits.contains(theId))
 248     myLineEdits[ theId ]->setEdited(isEditable);
 249 }
 250
 251 void SMESHGUI_FilterTable::AdditionalWidget::SetEditable (const bool isEditable)
 252 {
 253   QValueList<int> aParams;
 254   GetParameters(aParams);
 255   QValueList<int>::const_iterator anIter;
 256   for (anIter = aParams.begin(); anIter != aParams.end(); ++anIter)
 257     myLineEdits[ *anIter ]->setEdited(isEditable);
 258 }
 259
 260 /*
 261   Class       : SMESHGUI_FilterTable::ComboItem
 262   Description : Combo table item. Identificator corresponding to string may be assigned
 263 */
 264
 265 class SMESHGUI_FilterTable::ComboItem : public QComboTableItem
 266 {
 267 public:
 268                           ComboItem(QTable*, const QMap<int, QString>&);
 269   virtual                 ~ComboItem();
 270
 271   virtual void            setStringList (const QStringList & l);
 272   void                    setStringList(const QMap<int, QString>& theIds);
 273
 274   int                     GetValue() const;
 275   void                    SetValue(const int);
 276
 277 private:
 278
 279   QMap<int, int>          myNumToId;
 280   QMap<int, int>          myIdToNum;
 281 };
 282
 283 SMESHGUI_FilterTable::ComboItem::ComboItem (QTable*                   theParent,
 284                                             const QMap<int, QString>& theIds)
 285 : QComboTableItem(theParent, QStringList())
 286 {
 287   setStringList(theIds);
 288 }
 289
 290 void SMESHGUI_FilterTable::ComboItem::setStringList (const QStringList & l)
 291 {
 292   QComboTableItem::setStringList(l);
 293 }
 294
 295 void SMESHGUI_FilterTable::ComboItem::setStringList (const QMap<int, QString>& theIds)
 296 {
 297   int i = 0;
 298   QStringList aList;
 299   QMap<int, QString>::const_iterator anIter;
 300   for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter) {
 301     myNumToId[ i ] = anIter.key();
 302     myIdToNum[ anIter.key() ] = i;
 303     aList.append(anIter.data());
 304     i++;
 305   }
 306
 307   setStringList(aList);
 308 }
 309
 310 SMESHGUI_FilterTable::ComboItem::~ComboItem()
 311 {
 312 }
 313
 314 int SMESHGUI_FilterTable::ComboItem::GetValue() const
 315 {
 316   return myNumToId[ currentItem() ];
 317 }
 318
 319 void SMESHGUI_FilterTable::ComboItem::SetValue (const int theVal)
 320 {
 321   setCurrentItem(myIdToNum[ theVal ]);
 322 }
 323
 324
 325 /*
 326   Class       : SMESHGUI_FilterTable::Table
 327   Description : Table used by this widget
 328 */
 329
 330 class SMESHGUI_FilterTable::Table : public QTable
 331 {
 332 public:
 333                           Table(QWidget* parent);
 334                           Table(int numRows, int numCols, QWidget* parent = 0);
 335   virtual                 ~Table();
 336
 337   void                    SetEditable(const bool state, const int row, const int col);
 338   bool                    IsEditable(const int row, const int col) const;
 339
 340   virtual void            insertRows(int row, int count = 1);
 341   virtual QString         text(int row, int col) const;
 342 };
 343
 344 //=======================================================================
 345 // name    : SMESHGUI_FilterTable::Table::Table
 346 // Purpose : Constructor
 347 //=======================================================================
 348 SMESHGUI_FilterTable::Table::Table (QWidget* parent)
 349 : QTable(parent, "SMESHGUI_FilterTable::Table")
 350 {
 351 }
 352
 353 SMESHGUI_FilterTable::Table::Table (int numRows, int numCols, QWidget* parent)
 354 : QTable(numRows, numCols, parent, "SMESHGUI_FilterTable::Table")
 355 {
 356 }
 357
 358 SMESHGUI_FilterTable::Table::~Table()
 359 {
 360 }
 361
 362 //=======================================================================
 363 // name    : SMESHGUI_FilterTable::Table::SetEditable
 364 // Purpose : Set editable of specified cell
 365 //=======================================================================
 366 void SMESHGUI_FilterTable::Table::SetEditable (const bool isEditable,
 367                                                const int row, const int col)
 368 {
 369   QTableItem* anItem = item(row, col);
 370   if(anItem)
 371     takeItem(anItem);
 372
 373   if (!isEditable)
 374     setItem(row, col, new QTableItem(this, QTableItem::Never, ""));
 375   else
 376     setItem(row, col, new QTableItem(this, QTableItem::OnTyping, ""));
 377 }
 378
 379 //=======================================================================
 380 // name    : SMESHGUI_FilterTable::Table::IsEditable
 381 // Purpose : Verify wheter cell is editable
 382 //=======================================================================
 383 bool SMESHGUI_FilterTable::Table::IsEditable (const int row, const int col) const
 384 {
 385   QTableItem* anItem = item(row, col);
 386   return anItem == 0 || anItem->editType() != QTableItem::Never;
 387 }
 388
 389 //=======================================================================
 390 // name    : SMESHGUI_FilterTable::Table::insertRows
 391 // Purpose : Insert rows (virtual redefined)
 392 //=======================================================================
 393 void SMESHGUI_FilterTable::Table::insertRows (int row, int count)
 394 {
 395   int anEditRow = currEditRow();
 396   int anEditCol = currEditCol();
 397
 398   if (anEditRow >= 0 && anEditCol >= 0)
 399     endEdit(anEditRow, anEditCol, true, false);
 400
 401   QTable::insertRows( row, count );
 402 }
 403
 404 //=======================================================================
 405 // name    : SMESHGUI_FilterTable::Table::text
 406 // Purpose : Get text from cell (virtual redefined)
 407 //=======================================================================
 408 QString SMESHGUI_FilterTable::Table::text (int row, int col) const
 409 {
 410   int anEditRow = currEditRow();
 411   int anEditCol = currEditCol();
 412
 413   if (anEditRow >= 0 && anEditCol >= 0 && anEditRow == row && anEditCol == col)
 414     ((Table*)this)->endEdit(row, col, true, false);
 415
 416   return QTable::text(row, col);
 417 }
 418
 419
 420 /*
 421   Class       : SMESHGUI_FilterTable
 422   Description : Frame containig
 423                   - Button group for switching entity type
 424                   - Table for displaying filter criterions
 425                   - Buttons for editing table and filter libraries
 426 */
 427
 428 //=======================================================================
 429 // name    : SMESHGUI_FilterTable::SMESHGUI_FilterTable
 430 // Purpose : Constructor
 431 //=======================================================================
 432 SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule,
 433                                             QWidget* parent,
 434                                             const int type)
 435 : QFrame(parent),
 436   myIsLocked( false ),
 437   mySMESHGUI( theModule )
 438 {
 439   myEntityType = -1;
 440   Init(type);
 441 }
 442
 443 //=======================================================================
 444 // name    : SMESHGUI_FilterTable::SMESHGUI_FilterTable
 445 // Purpose : Constructor
 446 //=======================================================================
 447 SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule,
 448                                             QWidget* parent,
 449                                             const QValueList<int>& types)
 450 : QFrame(parent),
 451   myIsLocked( false ),
 452   mySMESHGUI( theModule )
 453 {
 454   myEntityType = -1;
 455   Init(types);
 456 }
 457
 458 SMESHGUI_FilterTable::~SMESHGUI_FilterTable()
 459 {
 460 }
 461
 462 //=======================================================================
 463 // name    : SMESHGUI_FilterTable::Init
 464 // Purpose : Create table corresponding to the specified type
 465 //=======================================================================
 466 void SMESHGUI_FilterTable::Init (const int type)
 467 {
 468   QValueList<int> aTypes;
 469   aTypes.append(type);
 470   Init(aTypes);
 471 }
 472
 473 //=======================================================================
 474 // name    : SMESHGUI_FilterTable::Init
 475 // Purpose : Create table corresponding to the specified type
 476 //=======================================================================
 477 void SMESHGUI_FilterTable::Init (const QValueList<int>& theTypes)
 478 {
 479   if (theTypes.isEmpty())
 480     return;
 481
 482   // Create buttons if necessary
 483
 484   if (myTables.isEmpty())
 485   {
 486     int aType = theTypes.first();
 487
 488     // create main layout
 489     QVBoxLayout* aMainLay = new QVBoxLayout(this);
 490     QGroupBox* aMainGrp = new QGroupBox(1, Qt::Horizontal, this);
 491     aMainGrp->setFrameStyle(QFrame::NoFrame);
 492     aMainGrp->setInsideMargin(0);
 493     aMainLay->addWidget(aMainGrp);
 494
 495     // create switch of entity types
 496     myEntityTypeGrp = new QButtonGroup(1, Qt::Vertical, tr("ENTITY_TYPE"), aMainGrp);
 497     const QMap<int, QString>& aSupportedTypes = getSupportedTypes();
 498     QMap<int, QString>::const_iterator anIter;
 499     for (anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter)
 500     {
 501       QRadioButton* aBtn = new QRadioButton(anIter.data(), myEntityTypeGrp);
 502       myEntityTypeGrp->insert(aBtn, anIter.key());
 503     }
 504
 505     myTableGrp = new QGroupBox(1, Qt::Horizontal, tr("FILTER"), aMainGrp );
 506     QFrame* aTableFrame = new QFrame(myTableGrp);
 507
 508     // create table
 509     mySwitchTableGrp = new QGroupBox(1, Qt::Horizontal, aTableFrame);
 510     mySwitchTableGrp->setFrameStyle(QFrame::NoFrame);
 511     mySwitchTableGrp->setInsideMargin(0);
 512
 513     myTables[ aType ] = createTable(mySwitchTableGrp, aType);
 514
 515     // create buttons
 516     myAddBtn      = new QPushButton(tr("ADD"), aTableFrame);
 517     myRemoveBtn   = new QPushButton(tr("REMOVE"), aTableFrame);
 518     myClearBtn    = new QPushButton(tr("CLEAR"), aTableFrame);
 519     myInsertBtn   = new QPushButton(tr("INSERT"), aTableFrame);
 520     myCopyFromBtn = new QPushButton(tr("COPY_FROM"), aTableFrame);
 521     myAddToBtn    = new QPushButton(tr("ADD_TO"), aTableFrame);
 522
 523     myAddBtn->setAutoDefault(false);
 524     myRemoveBtn->setAutoDefault(false);
 525     myClearBtn->setAutoDefault(false);
 526     myInsertBtn->setAutoDefault(false);
 527     myCopyFromBtn->setAutoDefault(false);
 528     myAddToBtn->setAutoDefault(false);
 529
 530     myCopyFromBtn->hide();
 531     myAddToBtn->hide();
 532
 533     // layout widgets
 534     QGridLayout* aLay = new QGridLayout(aTableFrame, 8, 2, 0, SPACING);
 535
 536     aLay->addMultiCellWidget(mySwitchTableGrp, 0, 6, 0, 0);
 537     aLay->addWidget(myAddBtn, 0, 1);
 538     aLay->addWidget(myInsertBtn, 1, 1);
 539     aLay->addWidget(myRemoveBtn, 2, 1);
 540     aLay->addWidget(myClearBtn, 3, 1);
 541     aLay->addWidget(myCopyFromBtn, 5, 1);
 542     aLay->addWidget(myAddToBtn, 6, 1);
 543     aLay->addMultiCellWidget(createAdditionalFrame(aTableFrame), 7, 7, 0, 1 );
 544
 545     aLay->setColStretch(0, 1);
 546     aLay->setColStretch(1, 0);
 547
 548     QSpacerItem* aVSpacer = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
 549     aLay->addItem(aVSpacer, 4, 1);
 550
 551     // signals and slots
 552     connect(myAddBtn,    SIGNAL(clicked()), this, SLOT(onAddBtn()));
 553     connect(myInsertBtn, SIGNAL(clicked()), this, SLOT(onInsertBtn()));
 554     connect(myRemoveBtn, SIGNAL(clicked()), this, SLOT(onRemoveBtn()));
 555     connect(myClearBtn,  SIGNAL(clicked()), this, SLOT(onClearBtn()));
 556
 557     connect(myCopyFromBtn, SIGNAL(clicked()), this, SLOT(onCopyFromBtn()));
 558     connect(myAddToBtn,    SIGNAL(clicked()), this, SLOT(onAddToBtn()));
 559
 560     connect(myEntityTypeGrp, SIGNAL(clicked(int)), this, SLOT(onEntityType(int)));
 561
 562     myLibDlg = 0;
 563   }
 564
 565   // Hide buttons of entity types if necessary
 566   const QMap<int, QString>& aSupportedTypes = getSupportedTypes();
 567   QMap<int, QString>::const_iterator anIt;
 568   for (anIt = aSupportedTypes.begin(); anIt != aSupportedTypes.end(); ++anIt)
 569   {
 570     QButton* aBtn = myEntityTypeGrp->find(anIt.key());
 571     theTypes.contains(anIt.key()) ? aBtn->show() : aBtn->hide();
 572   }
 573
 574   // select first button if there is no selected buttons or it is hidden
 575   QButton* aBtn = myEntityTypeGrp->selected();
 576   if ( aBtn == 0 || theTypes.find(myEntityTypeGrp->id(aBtn)) == theTypes.end())
 577     myEntityTypeGrp->setButton(theTypes.first());
 578
 579   if (theTypes.count() == 1)
 580     myEntityTypeGrp->hide();
 581   else
 582     myEntityTypeGrp->show();
 583
 584   myTableGrp->updateGeometry();
 585   int aType = myEntityTypeGrp->id(myEntityTypeGrp->selected());
 586   onEntityType(aType);
 587 }
 588
 589 //=======================================================================
 590 // name    : SMESHGUI_FilterTable::GetTableGrp
 591 // Purpose : Get group box containing table. May be used for adding new widgets in it
 592 //=======================================================================
 593 QWidget* SMESHGUI_FilterTable::createAdditionalFrame (QWidget* theParent)
 594 {
 595   QFrame* aFrame = new QFrame(theParent);
 596
 597   QFrame* aLine1 = new QFrame(aFrame);
 598   QFrame* aLine2 = new QFrame(aFrame);
 599   aLine1->setFrameStyle(QFrame::HLine | QFrame::Sunken);
 600   aLine2->setFrameStyle(QFrame::HLine | QFrame::Sunken);
 601   aLine1->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
 602   aLine2->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
 603
 604   QLabel* aLabel = new QLabel(tr("ADDITIONAL_PARAMETERS"), aFrame);
 605
 606   myWgStack = new QWidgetStack(aFrame);
 607
 608   QGridLayout* aLay = new QGridLayout(aFrame, 2, 3, 0, SPACING);
 609   aLay->addWidget(aLine1, 0, 0);
 610   aLay->addWidget(aLabel, 0, 1);
 611   aLay->addWidget(aLine2, 0, 2);
 612   aLay->addMultiCellWidget(myWgStack, 1, 1, 0, 2);
 613
 614   return aFrame;
 615 }
 616
 617 //=======================================================================
 618 // name    : SMESHGUI_FilterTable::GetTableGrp
 619 // Purpose : Get group box containing table. May be used for adding new widgets in it
 620 //=======================================================================
 621 QGroupBox* SMESHGUI_FilterTable::GetTableGrp()
 622 {
 623   return myTableGrp;
 624 }
 625
 626 //=======================================================================
 627 // name    : SMESHGUI_FilterTable::onEntityType
 628 // Purpose : SLOT. Called when entity type changed.
 629 //           Display corresponding table
 630 //=======================================================================
 631 void SMESHGUI_FilterTable::onEntityType (int theType)
 632 {
 633   if (myEntityType == theType)
 634     return;
 635
 636   myIsValid = true;
 637   emit NeedValidation();
 638   if (!myIsValid)
 639   {
 640     myEntityTypeGrp->setButton(myEntityType);
 641     return;
 642   }
 643
 644   myEntityType = theType;
 645
 646   if (!myTables.contains(theType))
 647     myTables[ theType ] = createTable(mySwitchTableGrp, theType);
 648
 649   TableMap::iterator anIter;
 650   for (anIter = myTables.begin(); anIter != myTables.end(); ++anIter)
 651     myEntityType == anIter.key() ? anIter.data()->show() : anIter.data()->hide();
 652
 653   updateBtnState();
 654   qApp->processEvents();
 655   myTables[ myEntityType ]->updateGeometry();
 656   adjustSize();
 657
 658   emit EntityTypeChanged(theType);
 659
 660 }
 661
 662 //=======================================================================
 663 // name    : SMESHGUI_FilterTable::IsValid
 664 // Purpose : Verify validity of entered data
 665 //=======================================================================
 666 bool SMESHGUI_FilterTable::IsValid (const bool theMess, const int theEntityType) const
 667 {
 668   int aType = theEntityType == -1 ? GetType() : theEntityType;
 669
 670   Table* aTable = myTables[ aType ];
 671   for (int i = 0, n = aTable->numRows(); i < n; i++)
 672   {
 673     int aCriterion = GetCriterionType(i, aType);
 674
 675     if (aCriterion == FT_RangeOfIds ||
 676          aCriterion == FT_BelongToGeom ||
 677          aCriterion == FT_BelongToPlane ||
 678          aCriterion == FT_BelongToCylinder ||
 679          aCriterion == FT_LyingOnGeom) {
 680       if (aTable->text(i, 2).isEmpty()) {
 681         if (theMess)
 682           QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
 683                                    tr("ERROR"), QMessageBox::Ok);
 684         return false;
 685       }
 686     } else {
 687       bool aRes = false;
 688       aTable->blockSignals(true);
 689       double  aThreshold = (int)aTable->text(i, 2).toDouble(&aRes);
 690       aTable->blockSignals(false);
 691
 692       if (!aRes && aTable->IsEditable(i, 2)) {
 693         if (theMess)
 694           QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
 695                                    tr("ERROR"), QMessageBox::Ok);
 696         return false;
 697       }
 698       else if (aType == SMESH::EDGE &&
 699                 GetCriterionType(i, aType) == SMESH::FT_MultiConnection &&
 700                 aThreshold == 1)
 701       {
 702         if (theMess)
 703           QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
 704                                    tr("MULTIEDGES_ERROR"), QMessageBox::Ok);
 705         return false;
 706       }
 707     }
 708
 709     QTableItem* anItem = aTable->item(i, 0);
 710     if (myAddWidgets.contains(anItem) && !myAddWidgets[ anItem ]->IsValid())
 711       return false;
 712   }
 713
 714   return true;
 715 }
 716
 717 //=======================================================================
 718 // name    : SMESHGUI_FilterTable::SetValidity
 719 // Purpose : Set validity of the table
 720 //=======================================================================
 721 void SMESHGUI_FilterTable::SetValidity (const bool isValid)
 722 {
 723   myIsValid = isValid;
 724 }
 725
 726 //=======================================================================
 727 // name    : SMESHGUI_FilterTable::GetType
 728 // Purpose : Get current entity type
 729 //=======================================================================
 730 int SMESHGUI_FilterTable::GetType() const
 731 {
 732   return myEntityType;
 733 }
 734
 735 //=======================================================================
 736 // name    : SMESHGUI_FilterTable::SetType
 737 // Purpose : Set current entity type
 738 //=======================================================================
 739 void SMESHGUI_FilterTable::SetType (const int type)
 740 {
 741   myEntityTypeGrp->setButton(type);
 742   onEntityType(type);
 743 }
 744
 745 //=======================================================================
 746 // name    : SMESHGUI_FilterTable::RestorePreviousEntityType
 747 // Purpose : Restore previous entity type
 748 //=======================================================================
 749 void SMESHGUI_FilterTable::RestorePreviousEntityType()
 750 {
 751   SetType(myEntityType);
 752 }
 753
 754 //=======================================================================
 755 // name    : SMESHGUI_FilterTable::GetCriterionType
 756 // Purpose : Get type of criterion from specified row (corresponding enums in h-file)
 757 //=======================================================================
 758 int SMESHGUI_FilterTable::GetCriterionType (const int theRow, const int theType) const
 759 {
 760   int aType = theType == -1 ? GetType() : theType;
 761   Table* aTable = myTables[ aType ];
 762   ComboItem* anItem = (ComboItem*)aTable->item(theRow, 0);
 763   return anItem != 0 ? anItem->GetValue() : FT_Undefined;
 764 }
 765
 766 //=======================================================================
 767 // name    : SMESHGUI_FilterTable::GetCriterion
 768 // Purpose : Get parameters of criterion from specified row
 769 //=======================================================================
 770 void SMESHGUI_FilterTable::GetCriterion (const int                 theRow,
 771                                          SMESH::Filter::Criterion& theCriterion,
 772                                          const int                 theEntityType) const
 773 {
 774   int aType = theEntityType == -1 ? GetType() : theEntityType;
 775   Table* aTable = myTables[ aType ];
 776
 777   theCriterion.Type = ((ComboItem*)aTable->item(theRow, 0))->GetValue();
 778   theCriterion.UnaryOp = ((QCheckTableItem*)aTable->item(theRow, 3))->isChecked() ? FT_LogicalNOT : FT_Undefined;
 779   theCriterion.BinaryOp = theRow != aTable->numRows() - 1 ?
 780     ((ComboItem*)aTable->item(theRow, 4))->GetValue() : FT_Undefined;
 781   theCriterion.TypeOfElement = (ElementType)aType;
 782
 783   int aCriterionType = GetCriterionType(theRow, aType);
 784
 785   if (aCriterionType != FT_RangeOfIds &&
 786        aCriterionType != FT_BelongToGeom &&
 787        aCriterionType != FT_BelongToPlane &&
 788        aCriterionType != FT_BelongToCylinder &&
 789        aCriterionType != FT_LyingOnGeom)
 790   {
 791     theCriterion.Compare = ((ComboItem*)aTable->item(theRow, 1))->GetValue();
 792     theCriterion.Threshold = aTable->item(theRow, 2)->text().toDouble();
 793   }
 794   else
 795     {
 796       theCriterion.ThresholdStr = aTable->text(theRow, 2).latin1();
 797       if ( aCriterionType != FT_RangeOfIds )
 798         theCriterion.ThresholdID = aTable->text( theRow, 5 ).latin1();
 799     }
 800
 801   QTableItem* anItem = aTable->item(theRow, 0);
 802   if (myAddWidgets.contains(anItem))
 803     theCriterion.Tolerance = myAddWidgets[ anItem ]->GetDouble(AdditionalWidget::Tolerance);
 804 }
 805
 806 //=======================================================================
 807 // name    : SMESHGUI_FilterTable::SetCriterion
 808 // Purpose : Set parameters of criterion of specified row
 809 //=======================================================================
 810 void SMESHGUI_FilterTable::SetCriterion (const int                       theRow,
 811                                          const SMESH::Filter::Criterion& theCriterion,
 812                                          const int                       theEntityType)
 813 {
 814   int aType = theEntityType == -1 ? GetType() : theEntityType;
 815
 816   Table* aTable = myTables[ aType ];
 817
 818   if (theRow > aTable->numRows() - 1)
 819     return;
 820
 821   ((ComboItem*)aTable->item(theRow, 0))->SetValue(theCriterion.Type);
 822   onCriterionChanged(theRow, 0, aType);
 823   ((ComboItem*)aTable->item(theRow, 1))->SetValue(theCriterion.Compare);
 824   ((QCheckTableItem*)aTable->item(theRow, 3))->setChecked(theCriterion.UnaryOp == FT_LogicalNOT);
 825
 826   if (theCriterion.BinaryOp != FT_Undefined)
 827   {
 828     if (!aTable->IsEditable(theRow, 4))
 829       aTable->setItem(theRow, 4, getBinaryItem(aTable));
 830     ((ComboItem*)aTable->item(theRow, 4))->SetValue(theCriterion.BinaryOp);
 831   }
 832   else
 833     aTable->SetEditable(false, theRow, 4);
 834
 835   if (theCriterion.Type != FT_RangeOfIds &&
 836       theCriterion.Type != FT_BelongToGeom &&
 837       theCriterion.Type != FT_BelongToPlane &&
 838       theCriterion.Type != FT_BelongToCylinder &&
 839       theCriterion.Type != FT_LyingOnGeom &&
 840       theCriterion.Type != FT_FreeBorders &&
 841       theCriterion.Type != FT_FreeEdges &&
 842       theCriterion.Type != FT_BadOrientedVolume)
 843     aTable->setText(theRow, 2, QString("%1").arg(theCriterion.Threshold, 0, 'g', 15));
 844   else
 845     {
 846       aTable->setText(theRow, 2, QString(theCriterion.ThresholdStr));
 847       if ( theCriterion.Type != FT_RangeOfIds )
 848         aTable->setText( theRow, 5, QString( theCriterion.ThresholdID ) );
 849     }
 850
 851   if (theCriterion.Compare == FT_EqualTo ||
 852        theCriterion.Type    == FT_BelongToPlane ||
 853        theCriterion.Type    == FT_BelongToCylinder)
 854   {
 855     QTableItem* anItem = aTable->item(theRow, 0);
 856     if (!myAddWidgets.contains(anItem))
 857     {
 858       myAddWidgets[ anItem ] = new AdditionalWidget(myWgStack);
 859       myWgStack->addWidget(myAddWidgets[ anItem ]);
 860     }
 861     myAddWidgets[ anItem ]->SetDouble(AdditionalWidget::Tolerance, theCriterion.Tolerance);
 862   }
 863
 864   emit CriterionChanged(theRow, aType);
 865
 866 }
 867
 868 //=======================================================================
 869 // name    : SMESHGUI_FilterTable::Update
 870 // Purpose : Update table
 871 //=======================================================================
 872 void SMESHGUI_FilterTable::Update()
 873 {
 874   Table* aTable = myTables[ GetType() ];
 875   int aCurrRow = aTable->currentRow();
 876   int numRows = aTable->numRows();
 877   if ((aCurrRow < 0 || aCurrRow >= numRows) && numRows > 0)
 878     aTable->setCurrentCell(0, 0);
 879   updateAdditionalWidget();
 880 }
 881
 882 //=======================================================================
 883 // name    : SMESHGUI_FilterTable::AddCriterion
 884 // Purpose : Add criterion with parameters
 885 //=======================================================================
 886 void SMESHGUI_FilterTable::AddCriterion (const SMESH::Filter::Criterion& theCriterion,
 887                                          const int                       theEntityType)
 888 {
 889   int aType = theEntityType == -1 ? GetType() : theEntityType;
 890   Table* aTable = myTables[ aType ];
 891   addRow(aTable, aType);
 892   SetCriterion(aTable->numRows() - 1, theCriterion);
 893 }
 894
 895 //=======================================================================
 896 // name    : SMESHGUI_FilterTable::NumRows
 897 // Purpose : Get number of criterions of current type
 898 //=======================================================================
 899 int SMESHGUI_FilterTable::NumRows (const int theEntityType) const
 900 {
 901   return myTables[ theEntityType == -1 ? GetType() : theEntityType ]->numRows();
 902 }
 903
 904 //=======================================================================
 905 // name    : SMESHGUI_FilterTable::Clear
 906 // Purpose : Clear current table
 907 //=======================================================================
 908 void SMESHGUI_FilterTable::Clear (const int theType)
 909 {
 910   int aType = theType == -1 ? GetType() : theType;
 911   QTable* aTable = myTables[ aType ];
 912
 913   if (aTable->numRows() == 0)
 914     return;
 915
 916   while (aTable->numRows() > 0)
 917   {
 918     removeAdditionalWidget(aTable, 0);
 919     aTable->removeRow(0);
 920   }
 921
 922   updateBtnState();
 923 }
 924
 925 //=======================================================================
 926 // name    : SMESHGUI_FilterTable::onAddBtn
 927 // Purpose : SLOT. Called then "Add" button pressed.
 928 //           Adds new string to table
 929 //=======================================================================
 930 void SMESHGUI_FilterTable::onAddBtn()
 931 {
 932   int aType = GetType();
 933   addRow(myTables[ aType ], aType);
 934
 935   Update();
 936 }
 937
 938 //=======================================================================
 939 // name    : SMESHGUI_FilterTable::onInsertBtn
 940 // Purpose : SLOT. Called then "Insert" button pressed.
 941 //           Inserts new string before current one
 942 //=======================================================================
 943 void SMESHGUI_FilterTable::onInsertBtn()
 944 {
 945   addRow(myTables[ GetType() ], GetType(), false);
 946 }
 947
 948 //=======================================================================
 949 // name    : SMESHGUI_FilterTable::onRemoveBtn
 950 // Purpose : SLOT. Called then "Remove" button pressed.
 951 //           Removes current string from table
 952 //=======================================================================
 953 void SMESHGUI_FilterTable::onRemoveBtn()
 954 {
 955   Table* aTable = myTables[ GetType() ];
 956
 957   if (aTable->numRows() == 0)
 958     return;
 959
 960   QMemArray<int> aRows;
 961   for (int i = 0, n = aTable->numRows(); i < n; i++)
 962   {
 963     if (aTable->isRowSelected(i))
 964     {
 965       aRows.resize(aRows.size() + 1);
 966       aRows[ aRows.size() - 1 ] = i;
 967       removeAdditionalWidget(aTable, i);
 968     }
 969   }
 970
 971   aTable->removeRows(aRows);
 972
 973   // remove control of binary logical operation from last row
 974   if (aTable->numRows() > 0)
 975     aTable->SetEditable(false, aTable->numRows() - 1, 4);
 976
 977   updateBtnState();
 978 }
 979
 980 //=======================================================================
 981 // name    : SMESHGUI_FilterTable::updateAdditionalWidget
 982 // Purpose : Enable/Disable widget with additonal parameters
 983 //=======================================================================
 984 void SMESHGUI_FilterTable::updateAdditionalWidget()
 985 {
 986   Table* aTable = myTables[ GetType() ];
 987   int aRow = aTable->currentRow();
 988   if (aRow < 0 || aRow >= aTable->numRows())
 989   {
 990     myWgStack->setEnabled(false);
 991     return;
 992   }
 993
 994   ComboItem* anItem = ((ComboItem*)aTable->item(aRow, 0));
 995   bool toEnable = ((ComboItem*)aTable->item(aRow, 1))->GetValue() == FT_EqualTo &&
 996                   GetCriterionType(aRow) != FT_BelongToGeom &&
 997                   GetCriterionType(aRow) != FT_LyingOnGeom &&
 998                   GetCriterionType(aRow) != FT_RangeOfIds &&
 999                   GetCriterionType(aRow) != FT_FreeEdges &&
1000                   GetCriterionType(aRow) != FT_BadOrientedVolume;
1001   if (!myAddWidgets.contains(anItem))
1002   {
1003     myAddWidgets[ anItem ] = new AdditionalWidget(myWgStack);
1004     myWgStack->addWidget(myAddWidgets[ anItem ]);
1005   }
1006
1007   myWgStack->raiseWidget(myWgStack->id(myAddWidgets[ anItem ]));
1008   myWgStack->setEnabled(toEnable);
1009 }
1010
1011 //=======================================================================
1012 // name    : SMESHGUI_FilterTable::removeAdditionalWidget
1013 // Purpose : Remove widgets containing additional parameters from widget
1014 //           stack and internal map
1015 //=======================================================================
1016 void SMESHGUI_FilterTable::removeAdditionalWidget (QTable* theTable, const int theRow)
1017 {
1018   QTableItem* anItem = theTable->item(theRow, 0);
1019   if (myAddWidgets.contains(anItem))
1020   {
1021     myWgStack->removeWidget(myAddWidgets[ anItem ]);
1022     myAddWidgets[ anItem ]->reparent(0, QPoint());
1023     delete myAddWidgets[ anItem ];
1024     myAddWidgets.remove(anItem);
1025   }
1026 }
1027
1028 //=======================================================================
1029 // name    : SMESHGUI_FilterTable::onClearBtn
1030 // Purpose : SLOT. Called then "Clear" button pressed.
1031 //           Removes all strings from table
1032 //=======================================================================
1033 void SMESHGUI_FilterTable::onClearBtn()
1034 {
1035   QTable* aTable = myTables[ GetType() ];
1036
1037   if (aTable->numRows() == 0)
1038     return;
1039
1040   while (aTable->numRows() > 0)
1041   {
1042     removeAdditionalWidget(aTable, 0);
1043     aTable->removeRow(0);
1044   }
1045
1046   updateBtnState();
1047 }
1048
1049 //=======================================================================
1050 // name    : SMESHGUI_FilterTable::onCurrentChanged()
1051 // Purpose : SLOT. Called when current cell changed
1052 //=======================================================================
1053 void SMESHGUI_FilterTable::onCurrentChanged (int theRow, int theCol)
1054 {
1055   if( !myIsLocked )
1056     updateAdditionalWidget();
1057   emit CurrentChanged(theRow, theCol);
1058 }
1059
1060 //=======================================================================
1061 // name    : SMESHGUI_FilterTable::onCriterionChanged()
1062 // Purpose : Provides reaction on change of criterion
1063 //=======================================================================
1064 void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int entityType)
1065 {
1066   int aType = entityType == -1 ? GetType() : entityType;
1067   Table* aTable = myTables[ aType ];
1068   ComboItem* aCompareItem = (ComboItem*)aTable->item(row, 1);
1069
1070   int aCriterionType = GetCriterionType(row);
1071
1072   if (aType == SMESH::EDGE && aCriterionType == SMESH::FT_FreeBorders ||
1073        aType == SMESH::FACE && aCriterionType == SMESH::FT_FreeEdges ||
1074        aType == SMESH::VOLUME && aCriterionType == SMESH::FT_BadOrientedVolume)
1075   {
1076     if (aCompareItem->count() > 0)
1077       aCompareItem->setStringList(QStringList());
1078     aTable->SetEditable(false, row, 2);
1079   }
1080   else if (aCriterionType == SMESH::FT_RangeOfIds ||
1081            aCriterionType == SMESH::FT_BelongToGeom ||
1082            aCriterionType == SMESH::FT_BelongToPlane ||
1083            aCriterionType == SMESH::FT_BelongToCylinder ||
1084            aCriterionType == SMESH::FT_LyingOnGeom)
1085   {
1086     QMap<int, QString> aMap;
1087     aMap[ FT_EqualTo ] = tr("EQUAL_TO");
1088     aCompareItem->setStringList(aMap);
1089     if (!aTable->IsEditable(row, 2))
1090       aTable->SetEditable(true, row, 2);
1091   }
1092   else
1093   {
1094     if (aCompareItem->count() != 3)
1095     {
1096       aCompareItem->setStringList(QStringList());
1097       aCompareItem->setStringList(getCompare());
1098     }
1099
1100     QString aText = aTable->text(row, 2);
1101     bool isOk = false;
1102     aText.toDouble(&isOk);
1103     aTable->setText(row, 2, isOk ? aText : QString(""));
1104     if (!aTable->IsEditable(row, 2))
1105       aTable->SetEditable(true, row, 2);
1106   }
1107
1108   updateAdditionalWidget();
1109
1110   emit CriterionChanged(row, entityType);
1111 }
1112
1113 //=======================================================================
1114 // name    : SMESHGUI_FilterTable::onCriterionChanged()
1115 // Purpose : SLOT. Called then contents of table changed
1116 //           Provides reaction on change of criterion
1117 //=======================================================================
1118 void SMESHGUI_FilterTable::onCriterionChanged (int row, int col)
1119 {
1120   onCriterionChanged(row, col, -1);
1121 }
1122
1123 //=======================================================================
1124 // name    : SMESHGUI_FilterTable::getFirstSelectedRow
1125 // Purpose : Get first selected row
1126 //=======================================================================
1127 int SMESHGUI_FilterTable::getFirstSelectedRow() const
1128 {
1129   QTable* aTable = myTables[ GetType() ];
1130   for (int i = 0, n = aTable->numRows(); i < n; i++)
1131     if (aTable->isRowSelected(i))
1132       return i;
1133
1134   int aRow = aTable->currentRow();
1135   return aRow >= 0 && aRow < aTable->numRows() ? aRow : -1;
1136 }
1137
1138 //=======================================================================
1139 // name    : SMESHGUI_FilterTable::addRow
1140 // Purpose : Add row at the end of table
1141 //=======================================================================
1142 void SMESHGUI_FilterTable::addRow (Table* theTable, const int theType, const bool toTheEnd)
1143 {
1144   int aCurrRow = 0;
1145   int aSelectedRow = getFirstSelectedRow();
1146   int aCurrCol = theTable->currentColumn();
1147
1148   myIsLocked = true;
1149   if (toTheEnd || aSelectedRow == -1)
1150   {
1151     theTable->insertRows(theTable->numRows());
1152     aCurrRow = theTable->numRows() - 1;
1153   }
1154   else
1155   {
1156     theTable->insertRows(aSelectedRow);
1157     aCurrRow = aSelectedRow;
1158   }
1159   myIsLocked = false;
1160
1161   // Criteria
1162   theTable->setItem(aCurrRow, 0, getCriterionItem(theTable, theType));
1163
1164   // Compare
1165   theTable->setItem(aCurrRow, 1, getCompareItem(theTable));
1166
1167   // Threshold
1168   //theTable->setItem(aCurrRow, 2, new QTableItem(theTable));
1169
1170   //Logical operation NOT
1171   theTable->setItem(aCurrRow, 3, getUnaryItem(theTable));
1172
1173   // Logical binary operation for previous value
1174   int anAddBinOpStr = -1;
1175   if (aCurrRow == theTable->numRows() - 1)
1176     anAddBinOpStr = aCurrRow - 1;
1177   else if (aCurrRow >= 0 )
1178     anAddBinOpStr = aCurrRow;
1179
1180   if (theTable->item(aCurrRow, 4) == 0 ||
1181        theTable->item(aCurrRow, 4)->rtti() != 1)
1182   {
1183
1184
1185     if (anAddBinOpStr >= 0 &&
1186          (theTable->item(anAddBinOpStr, 4) == 0 ||
1187            theTable->item(anAddBinOpStr, 4)->rtti() != 1))
1188       theTable->setItem(anAddBinOpStr, 4, getBinaryItem(theTable));
1189   }
1190
1191   theTable->SetEditable(false, theTable->numRows() - 1, 4);
1192
1193   if (aCurrRow >=0 && aCurrRow < theTable->numRows() &&
1194        aCurrCol >=0 && aCurrCol < theTable->numRows())
1195   theTable->setCurrentCell(aCurrRow, aCurrCol);
1196
1197   onCriterionChanged(aCurrRow, 0);
1198
1199   updateBtnState();
1200 }
1201
1202 //=======================================================================
1203 // name    : SMESHGUI_FilterTable::getCriterionItem
1204 // Purpose : Get combo table item for criteria of specified type
1205 //=======================================================================
1206 QTableItem* SMESHGUI_FilterTable::getCriterionItem (QTable* theParent , const int theType)
1207 {
1208   return new ComboItem(theParent, getCriteria(theType));
1209 }
1210
1211 //=======================================================================
1212 // name    : SMESHGUI_FilterTable::getCompareItem
1213 // Purpose : Get combo table item for operation of comparision
1214 //=======================================================================
1215 QTableItem* SMESHGUI_FilterTable::getCompareItem (QTable* theParent)
1216 {
1217   return new ComboItem(theParent, getCompare());
1218 }
1219
1220 //=======================================================================
1221 // name    : SMESHGUI_FilterTable::getBinaryItem
1222 // Purpose :
1223 //=======================================================================
1224 QTableItem* SMESHGUI_FilterTable::getBinaryItem (QTable* theParent)
1225 {
1226   static QMap<int, QString> aMap;
1227   if (aMap.isEmpty())
1228   {
1229     aMap[ SMESH::FT_LogicalAND ] = tr("AND");
1230     aMap[ SMESH::FT_LogicalOR  ] = tr("OR");
1231   }
1232
1233   return new ComboItem(theParent, aMap);
1234 }
1235
1236 //=======================================================================
1237 // name    : SMESHGUI_FilterTable::getUnaryItem
1238 // Purpose : Get check table item
1239 //=======================================================================
1240 QTableItem* SMESHGUI_FilterTable::getUnaryItem (QTable* theParent)
1241 {
1242   return new QCheckTableItem(theParent, tr("NOT"));
1243 }
1244
1245 //=======================================================================
1246 // name    : SMESHGUI_FilterTable::getSupportedTypes
1247 // Purpose : Get all supported type
1248 //=======================================================================
1249 const QMap<int, QString>& SMESHGUI_FilterTable::getSupportedTypes() const
1250 {
1251   static QMap<int, QString> aTypes;
1252   if (aTypes.isEmpty())
1253   {
1254     aTypes[ SMESH::NODE   ] = tr("NODES");
1255     aTypes[ SMESH::EDGE   ] = tr("EDGES");
1256     aTypes[ SMESH::FACE   ] = tr("FACES");
1257     aTypes[ SMESH::VOLUME ] = tr("VOLUMES");
1258   }
1259
1260   return aTypes;
1261 }
1262
1263 //=======================================================================
1264 // name    : SMESHGUI_FilterTable::getCriteria
1265 // Purpose : Get criteria for specified type
1266 //=======================================================================
1267 const QMap<int, QString>& SMESHGUI_FilterTable::getCriteria (const int theType) const
1268 {
1269   if (theType == SMESH::NODE)
1270   {
1271     static QMap<int, QString> aCriteria;
1272     if (aCriteria.isEmpty())
1273     {
1274       aCriteria[ SMESH::FT_RangeOfIds       ] = tr("RANGE_OF_IDS");
1275       aCriteria[ SMESH::FT_BelongToGeom     ] = tr("BELONG_TO_GEOM");
1276       aCriteria[ SMESH::FT_BelongToPlane    ] = tr("BELONG_TO_PLANE");
1277       aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER");
1278       aCriteria[ SMESH::FT_LyingOnGeom      ] = tr("LYING_ON_GEOM");
1279     }
1280     return aCriteria;
1281   }
1282   else if (theType == SMESH::EDGE)
1283   {
1284     static QMap<int, QString> aCriteria;
1285     if (aCriteria.isEmpty())
1286     {
1287       aCriteria[ SMESH::FT_FreeBorders      ] = tr("FREE_BORDERS");
1288       aCriteria[ SMESH::FT_MultiConnection  ] = tr("MULTI_BORDERS");
1289       aCriteria[ SMESH::FT_Length           ] = tr("LENGTH");
1290       aCriteria[ SMESH::FT_RangeOfIds       ] = tr("RANGE_OF_IDS");
1291       aCriteria[ SMESH::FT_BelongToGeom     ] = tr("BELONG_TO_GEOM");
1292       aCriteria[ SMESH::FT_BelongToPlane    ] = tr("BELONG_TO_PLANE");
1293       aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER");
1294       aCriteria[ SMESH::FT_LyingOnGeom      ] = tr("LYING_ON_GEOM");
1295     }
1296     return aCriteria;
1297   }
1298   else if (theType == SMESH::FACE)
1299   {
1300     static QMap<int, QString> aCriteria;
1301     if (aCriteria.isEmpty())
1302     {
1303       aCriteria[ SMESH::FT_AspectRatio      ] = tr("ASPECT_RATIO");
1304       aCriteria[ SMESH::FT_Warping          ] = tr("WARPING");
1305       aCriteria[ SMESH::FT_MinimumAngle     ] = tr("MINIMUM_ANGLE");
1306       aCriteria[ SMESH::FT_Taper            ] = tr("TAPER");
1307       aCriteria[ SMESH::FT_Skew             ] = tr("SKEW");
1308       aCriteria[ SMESH::FT_Area             ] = tr("AREA");
1309       aCriteria[ SMESH::FT_FreeEdges        ] = tr("FREE_EDGES");
1310       aCriteria[ SMESH::FT_RangeOfIds       ] = tr("RANGE_OF_IDS");
1311       aCriteria[ SMESH::FT_BelongToGeom     ] = tr("BELONG_TO_GEOM");
1312       aCriteria[ SMESH::FT_BelongToPlane    ] = tr("BELONG_TO_PLANE");
1313       aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER");
1314       aCriteria[ SMESH::FT_LyingOnGeom      ] = tr("LYING_ON_GEOM");
1315       aCriteria[ SMESH::FT_Length2D         ] = tr("LENGTH2D");
1316       aCriteria[ SMESH::FT_MultiConnection2D] = tr("MULTI2D_BORDERS");
1317     }
1318     return aCriteria;
1319   }
1320   else if (theType == SMESH::VOLUME)
1321   {
1322     static QMap<int, QString> aCriteria;
1323     if (aCriteria.isEmpty())
1324     {
1325       aCriteria[ SMESH::FT_AspectRatio3D] = tr("ASPECT_RATIO_3D");
1326       aCriteria[ SMESH::FT_RangeOfIds   ] = tr("RANGE_OF_IDS");
1327       aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM");
1328       aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM");
1329       aCriteria[ SMESH::FT_BadOrientedVolume ] = tr("BAD_ORIENTED_VOLUME");
1330       aCriteria[ SMESH::FT_Volume3D ] = tr("VOLUME_3D");
1331     }
1332     return aCriteria;
1333   }
1334   else
1335   {
1336     static QMap<int, QString> aCriteria;
1337     return aCriteria;
1338   }
1339 }
1340
1341
1342 //=======================================================================
1343 // name    : SMESHGUI_FilterTable::getCompare
1344 // Purpose : Get operation of comparison
1345 //=======================================================================
1346 const QMap<int, QString>& SMESHGUI_FilterTable::getCompare() const
1347 {
1348   static QMap<int, QString> aMap;
1349
1350   if (aMap.isEmpty())
1351   {
1352     aMap[ SMESH::FT_LessThan ] = tr("LESS_THAN");
1353     aMap[ SMESH::FT_MoreThan ] = tr("MORE_THAN");
1354     aMap[ SMESH::FT_EqualTo  ] = tr("EQUAL_TO" );
1355   }
1356
1357   return aMap;
1358 }
1359
1360 //=======================================================================
1361 // name    : SMESHGUI_FilterTable::createTable
1362 // Purpose : Create table
1363 //=======================================================================
1364 SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget*  theParent,
1365                                                                 const int theType)
1366 {
1367   // create table
1368   Table* aTable= new Table(0, 6, theParent);
1369
1370   QHeader* aHeaders = aTable->horizontalHeader();
1371
1372   QFontMetrics aMetrics(aHeaders->font());
1373
1374   // append spaces to the header of criteria in order to
1375   // provide visibility of criterion inside comboboxes
1376   static int aMaxLenCr = 0;
1377
1378   if (aMaxLenCr == 0)
1379   {
1380     const QMap<int, QString>& aSupportedTypes = getSupportedTypes();
1381     QMap<int, QString>::const_iterator anIter;
1382     for (anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter)
1383       aMaxLenCr = Max(maxLength(getCriteria(anIter.key()), aMetrics), aMaxLenCr);
1384   }
1385
1386   static int aLenCr = abs( aMaxLenCr -
1387                             aMetrics.width(tr("CRITERION"))) / aMetrics.width(' ') + 5;
1388
1389   QString aCrStr;
1390   aCrStr.fill(' ', aLenCr);
1391   QString aCoStr;
1392   aCoStr.fill(' ', 10);
1393
1394   aHeaders->setLabel(0, tr("CRITERION") + aCrStr);
1395   aHeaders->setLabel(1, tr("COMPARE") + aCoStr);
1396   aHeaders->setLabel(2, tr("THRESHOLD_VALUE"));
1397   aHeaders->setLabel(3, tr("UNARY"));
1398   aHeaders->setLabel(4, tr("BINARY") + "  ");
1399   aHeaders->setLabel( 5, tr( "ID" ) );
1400
1401   // set geometry of the table
1402   for (int i = 0; i <= 4; i++)
1403     aTable->adjustColumn(i);
1404
1405   // set the ID column invisible
1406   aTable->hideColumn( 5 );
1407
1408   aTable->updateGeometry();
1409   QSize aSize = aTable->sizeHint();
1410   int aWidth = aSize.width();
1411   aTable->setMinimumSize(QSize(aWidth, aWidth / 2));
1412   aTable->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
1413
1414   connect(aTable, SIGNAL(valueChanged(int, int)),
1415            this,   SLOT(onCriterionChanged(int, int)));
1416
1417   connect(aTable, SIGNAL(currentChanged(int, int)),
1418            this,   SLOT(onCurrentChanged(int, int)));
1419
1420   return aTable;
1421 }
1422
1423 //=======================================================================
1424 // name    : SMESHGUI_FilterTable::updateBtnState
1425 // Purpose : Update button state
1426 //=======================================================================
1427 void SMESHGUI_FilterTable::updateBtnState()
1428 {
1429   myRemoveBtn->setEnabled(myTables[ GetType() ]->numRows() > 0);
1430   myClearBtn->setEnabled(myTables[ GetType() ]->numRows() > 0);
1431 }
1432
1433 //=======================================================================
1434 // name    : SMESHGUI_FilterTable::SetEditable
1435 // Purpose : Set read only flag for tables. Show/hide buttons for work with rows
1436 //=======================================================================
1437 void SMESHGUI_FilterTable::SetEditable (const bool isEditable)
1438 {
1439   TableMap::iterator anIter;
1440   for (anIter = myTables.begin(); anIter != myTables.end(); ++anIter)
1441   {
1442     anIter.data()->setReadOnly(!isEditable);
1443
1444     if (isEditable)
1445     {
1446       myAddBtn->show();
1447       myInsertBtn->show();
1448       myRemoveBtn->show();
1449       myClearBtn->show();
1450     }
1451     else
1452     {
1453       myAddBtn->hide();
1454       myInsertBtn->hide();
1455       myRemoveBtn->hide();
1456       myClearBtn->hide();
1457     }
1458   }
1459
1460   QMap<QTableItem*, AdditionalWidget*>::iterator anIter2;
1461   for (anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2)
1462     anIter2.data()->SetEditable(isEditable);
1463 }
1464
1465 //=======================================================================
1466 // name    : SMESHGUI_FilterTable::SetEnabled
1467 // Purpose : Enable/Disable table. Switching type of elements already enabled
1468 //=======================================================================
1469 void SMESHGUI_FilterTable::SetEnabled (const bool isEnabled)
1470 {
1471   myAddBtn->setEnabled(isEnabled);
1472   myInsertBtn->setEnabled(isEnabled);
1473   myRemoveBtn->setEnabled(isEnabled);
1474   myClearBtn->setEnabled(isEnabled);
1475
1476   if (isEnabled)
1477     updateBtnState();
1478
1479   QMap<QTableItem*, AdditionalWidget*>::iterator anIter2;
1480   for (anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2)
1481     anIter2.data()->setEnabled(isEnabled);
1482 }
1483
1484 //=======================================================================
1485 // name    : SMESHGUI_FilterTable::IsEditable
1486 // Purpose : Verify whether table is editable
1487 //=======================================================================
1488 bool SMESHGUI_FilterTable::IsEditable() const
1489 {
1490   return !myTables[ GetType() ]->isReadOnly();
1491 }
1492
1493 //=======================================================================
1494 // name    : SMESHGUI_FilterTable::SetLibsEnabled
1495 // Purpose : Show/hide buttons for work with libraries
1496 //=======================================================================
1497 void SMESHGUI_FilterTable::SetLibsEnabled (const bool isEnabled)
1498 {
1499   if (isEnabled)
1500   {
1501     myCopyFromBtn->show();
1502     myAddToBtn->show();
1503   }
1504   else
1505   {
1506     myCopyFromBtn->hide();
1507     myAddToBtn->hide();
1508   }
1509 }
1510
1511 //=======================================================================
1512 // name    : SMESHGUI_FilterTable::onCopyFromBtn
1513 // Purpose : SLOT. Called the "Copy from ..." button clicked
1514 //           Display filter library dialog
1515 //=======================================================================
1516 void SMESHGUI_FilterTable::onCopyFromBtn()
1517 {
1518   if (myLibDlg == 0)
1519     myLibDlg = new SMESHGUI_FilterLibraryDlg(
1520       mySMESHGUI, this, GetType(), SMESHGUI_FilterLibraryDlg::COPY_FROM);
1521   else
1522     myLibDlg->Init(GetType(), SMESHGUI_FilterLibraryDlg::COPY_FROM);
1523
1524   if (myLibDlg->exec() == QDialog::Accepted)
1525   {
1526     Copy(myLibDlg->GetTable());
1527     Update();
1528   }
1529 }
1530
1531 //=======================================================================
1532 // name    : SMESHGUI_FilterTable::onAddToBtn
1533 // Purpose : SLOT. Called the "Add to ..." button clicked
1534 //           Display filter library dialog
1535 //=======================================================================
1536 void SMESHGUI_FilterTable::onAddToBtn()
1537 {
1538   if (!IsValid(true))
1539     return;
1540   if (myLibDlg == 0)
1541     myLibDlg = new SMESHGUI_FilterLibraryDlg(
1542       mySMESHGUI, this, GetType(), SMESHGUI_FilterLibraryDlg::ADD_TO);
1543   else
1544     myLibDlg->Init(GetType(), SMESHGUI_FilterLibraryDlg::ADD_TO);
1545
1546   myLibDlg->SetTable(this);
1547
1548   myLibDlg->exec();
1549 }
1550
1551 //=======================================================================
1552 // name    : SMESHGUI_FilterTable::Copy
1553 // Purpose : Initialise table with values of other table
1554 //=======================================================================
1555 void SMESHGUI_FilterTable::Copy (const SMESHGUI_FilterTable* theTable)
1556 {
1557   Clear();
1558
1559   for (int i = 0, n = theTable->NumRows(); i < n; i++)
1560   {
1561     SMESH::Filter::Criterion aCriterion = SMESHGUI_FilterDlg::createCriterion();
1562     theTable->GetCriterion(i, aCriterion);
1563     AddCriterion(aCriterion);
1564   }
1565 }
1566
1567 //=======================================================================
1568 // name    : SMESHGUI_FilterTable::CurrentCell
1569 // Purpose : Returns current cell
1570 //=======================================================================
1571 bool SMESHGUI_FilterTable::CurrentCell (int& theRow, int& theCol) const
1572 {
1573   theRow = myTables[ GetType() ]->currentRow();
1574   theCol = myTables[ GetType() ]->currentColumn();
1575   return theRow >= 0 && theCol >= 0;
1576 }
1577
1578 //=======================================================================
1579 // name    : SMESHGUI_FilterTable::SetText
1580 // Purpose : Set text and internal value in cell of threshold value
1581 //=======================================================================
1582 void SMESHGUI_FilterTable::SetThreshold (const int      theRow,
1583                                          const QString& theText,
1584                                          const int      theEntityType)
1585 {
1586   Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ];
1587   aTable->setText(theRow, 2, theText);
1588 }
1589
1590 //=======================================================================
1591 // name    : SMESHGUI_FilterTable::SetText
1592 // Purpose : Get text and internal value from cell of threshold value
1593 //=======================================================================
1594 bool SMESHGUI_FilterTable::GetThreshold (const int      theRow,
1595                                          QString&       theText,
1596                                          const int      theEntityType)
1597 {
1598   Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ];
1599   QTableItem* anItem = aTable->item(theRow, 2);
1600   if (anItem != 0)
1601   {
1602     theText = anItem->text();
1603     return true;
1604   }
1605   else
1606    return false;
1607 }
1608
1609 //=======================================================================
1610 // name    : SMESHGUI_FilterTable::SetID
1611 // Purpose : Set text and internal value in cell of ID value
1612 //=======================================================================
1613 void SMESHGUI_FilterTable::SetID( const int      theRow,
1614                                          const QString& theText,
1615                                          const int      theEntityType )
1616 {
1617   Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ];
1618   aTable->setText( theRow, 5, theText );
1619 }
1620
1621 //=======================================================================
1622 // name    : SMESHGUI_FilterTable::GetID
1623 // Purpose : Get text and internal value from cell of ID value
1624 //=======================================================================
1625 bool SMESHGUI_FilterTable::GetID( const int      theRow,
1626                                   QString&       theText,
1627                                   const int      theEntityType )
1628 {
1629   Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ];
1630   QTableItem* anItem = aTable->item( theRow, 5 );
1631   if ( anItem != 0 )
1632     {
1633       theText = anItem->text();
1634       return true;
1635     }
1636   else
1637     return false;
1638 }
1639
1640 /*
1641   Class       : SMESHGUI_FilterDlg
1642   Description : Dialog to specify filters for VTK viewer
1643 */
1644
1645
1646 //=======================================================================
1647 // name    : SMESHGUI_FilterDlg::SMESHGUI_FilterDlg
1648 // Purpose : Constructor
1649 //=======================================================================
1650 SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI*              theModule,
1651                                         const QValueList<int>& theTypes,
1652                                         const char*            theName)
1653 : QDialog( SMESH::GetDesktop( theModule ), theName, false,
1654            WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu),
1655      mySMESHGUI( theModule ),
1656      mySelectionMgr( SMESH::GetSelectionMgr( theModule ) )
1657 {
1658   if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
1659     mySelector = aViewWindow->GetSelector();
1660
1661   construct(theTypes);
1662 }
1663
1664 //=======================================================================
1665 // name    : SMESHGUI_FilterDlg::SMESHGUI_FilterDlg
1666 // Purpose : Constructor
1667 //=======================================================================
1668 SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI*   theModule,
1669                                         const int   theType,
1670                                         const char* theName)
1671 : QDialog( SMESH::GetDesktop( theModule ), theName, false,
1672            WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu),
1673      mySMESHGUI( theModule ),
1674      mySelectionMgr( SMESH::GetSelectionMgr( theModule ) )
1675 {
1676   if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
1677     mySelector = aViewWindow->GetSelector();
1678   QValueList<int> aTypes;
1679   aTypes.append(theType);
1680   construct(aTypes);
1681 }
1682
1683 //=======================================================================
1684 // name    : SMESHGUI_FilterDlg::construct
1685 // Purpose : Construct dialog (called by constructor)
1686 //=======================================================================
1687 void SMESHGUI_FilterDlg::construct (const QValueList<int>& theTypes)
1688 {
1689   myTypes = theTypes;
1690
1691   setCaption(tr("CAPTION"));
1692
1693   QVBoxLayout* aDlgLay = new QVBoxLayout (this, MARGIN, SPACING);
1694
1695   myMainFrame        = createMainFrame  (this);
1696   QFrame* aBtnFrame  = createButtonFrame(this);
1697
1698   aDlgLay->addWidget(myMainFrame);
1699   aDlgLay->addWidget(aBtnFrame);
1700
1701   aDlgLay->setStretchFactor(myMainFrame, 1);
1702
1703   myHelpFileName = "selection_filter_library.htm";
1704
1705   Init(myTypes);
1706 }
1707
1708 //=======================================================================
1709 // name    : SMESHGUI_FilterDlg::createMainFrame
1710 // Purpose : Create frame containing dialog's input fields
1711 //=======================================================================
1712 QFrame* SMESHGUI_FilterDlg::createMainFrame (QWidget* theParent)
1713 {
1714   QGroupBox* aMainFrame = new QGroupBox(1, Qt::Horizontal, theParent);
1715   aMainFrame->setFrameStyle(QFrame::NoFrame);
1716   aMainFrame->setInsideMargin(0);
1717
1718   // filter frame
1719
1720   myTable = new SMESHGUI_FilterTable( mySMESHGUI, aMainFrame, myTypes );
1721   myTable->SetLibsEnabled(true);
1722
1723   QFrame* aLine = new QFrame(myTable->GetTableGrp());
1724   aLine->setFrameStyle(QFrame::HLine | QFrame::Sunken);
1725
1726   mySetInViewer = new QCheckBox(tr("SET_IN_VIEWER"), myTable->GetTableGrp());
1727   mySetInViewer->setChecked(true);
1728
1729   // other controls
1730   mySourceGrp = createSourceGroup(aMainFrame);
1731
1732   connect(myTable, SIGNAL(CriterionChanged(const int, const int)),
1733                     SLOT(onCriterionChanged(const int, const int)));
1734
1735   connect(myTable, SIGNAL(CurrentChanged(int, int)),
1736                     SLOT(onCurrentChanged(int, int)));
1737
1738   return aMainFrame;
1739 }
1740
1741 //=======================================================================
1742 // name    : SMESHGUI_FilterDlg::createSourceFrame
1743 // Purpose : Create frame containing source radio button
1744 //=======================================================================
1745 QButtonGroup* SMESHGUI_FilterDlg::createSourceGroup (QWidget* theParent)
1746 {
1747   QButtonGroup* aGrp = new QButtonGroup(1, Qt::Vertical, tr("SOURCE"), theParent);
1748
1749   QRadioButton* aMeshBtn = new QRadioButton(tr("MESH"), aGrp);
1750   QRadioButton* aSelBtn  = new QRadioButton(tr("SELECTION"), aGrp);
1751   QRadioButton* aGrpBtn  = new QRadioButton(tr("CURRENT_GROUP"), aGrp);
1752
1753   aGrp->insert(aMeshBtn, Mesh);
1754   aGrp->insert(aSelBtn, Selection);
1755   aGrp->insert(aGrpBtn, Dialog);
1756
1757   aGrp->setButton(Selection);
1758
1759   return aGrp;
1760 }
1761
1762 //=======================================================================
1763 // name    : SMESHGUI_FilterDlg::updateMainButtons
1764 // Purpose : Update visibility of main buttons (OK, Cancel, Close ...)
1765 //=======================================================================
1766 void SMESHGUI_FilterDlg::updateMainButtons()
1767 {
1768   if (myTypes.count() == 1)
1769   {
1770     myButtons[ BTN_Cancel ]->show();
1771     myButtons[ BTN_Apply  ]->hide();
1772     myButtons[ BTN_Close  ]->hide();
1773   }
1774   else
1775   {
1776     myButtons[ BTN_Cancel ]->hide();
1777     myButtons[ BTN_Apply  ]->show();
1778     myButtons[ BTN_Close  ]->show();
1779   }
1780
1781 //  updateGeometry();
1782 }
1783
1784 //=======================================================================
1785 // name    : SMESHGUI_FilterDlg::createButtonFrame
1786 // Purpose : Create frame containing buttons
1787 //=======================================================================
1788 QFrame* SMESHGUI_FilterDlg::createButtonFrame (QWidget* theParent)
1789 {
1790   QGroupBox* aGrp = new QGroupBox(1, Qt::Vertical, theParent);
1791
1792   myButtons[ BTN_OK    ] = new QPushButton(tr("SMESH_BUT_OK"   ), aGrp);
1793   myButtons[ BTN_Apply ] = new QPushButton(tr("SMESH_BUT_APPLY"), aGrp);
1794
1795   QLabel* aLbl = new QLabel(aGrp);
1796   aLbl->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
1797
1798   myButtons[ BTN_Cancel ] = new QPushButton(tr("SMESH_BUT_CANCEL"), aGrp);
1799   myButtons[ BTN_Close  ] = new QPushButton(tr("SMESH_BUT_CLOSE"), aGrp);
1800   myButtons[ BTN_Help  ] = new QPushButton(tr("SMESH_BUT_HELP"), aGrp);
1801
1802   connect(myButtons[ BTN_OK     ], SIGNAL(clicked()), SLOT(onOk()));
1803   connect(myButtons[ BTN_Cancel ], SIGNAL(clicked()), SLOT(onClose()));
1804   connect(myButtons[ BTN_Close  ], SIGNAL(clicked()), SLOT(onClose()));
1805   connect(myButtons[ BTN_Apply  ], SIGNAL(clicked()), SLOT(onApply()));
1806   connect(myButtons[ BTN_Help   ], SIGNAL(clicked()), SLOT(onHelp()));
1807
1808   updateMainButtons();
1809
1810   return aGrp;
1811 }
1812
1813 //=======================================================================
1814 // name    : SMESHGUI_FilterDlg::~SMESHGUI_FilterDlg
1815 // Purpose : Destructor
1816 //=======================================================================
1817 SMESHGUI_FilterDlg::~SMESHGUI_FilterDlg()
1818 {
1819 }
1820
1821 //=======================================================================
1822 // name    : SMESHGUI_FilterDlg::Init
1823 // Purpose : Init dialog fields, connect signals and slots, show dialog
1824 //=======================================================================
1825 void SMESHGUI_FilterDlg::Init (const int type)
1826 {
1827   QValueList<int> aTypes;
1828   aTypes.append(type);
1829   Init(aTypes);
1830 }
1831
1832 //=======================================================================
1833 // name    : SMESHGUI_FilterDlg::Init
1834 // Purpose : Init dialog fields, connect signals and slots, show dialog
1835 //=======================================================================
1836 void SMESHGUI_FilterDlg::Init (const QValueList<int>& theTypes)
1837 {
1838   mySourceWg  = 0;
1839   myTypes     = theTypes;
1840   myMesh      = SMESH::SMESH_Mesh::_nil();
1841   myIObjects.Clear();
1842   myIsSelectionChanged = false;
1843
1844   myTable->Init(theTypes);
1845
1846   // set caption
1847   if (theTypes.count() == 1)
1848   {
1849     int aType = theTypes.first();
1850     if      (aType == SMESH::NODE  ) setCaption(tr("NODES_TLT"));
1851     else if (aType == SMESH::EDGE  ) setCaption(tr("EDGES_TLT"));
1852     else if (aType == SMESH::FACE  ) setCaption(tr("FACES_TLT"));
1853     else if (aType == SMESH::VOLUME) setCaption(tr("VOLUMES_TLT"));
1854   }
1855   else
1856     setCaption(tr("TLT"));
1857
1858   qApp->processEvents();
1859   updateGeometry();
1860   adjustSize();
1861   setEnabled(true);
1862
1863   mySMESHGUI->SetActiveDialogBox((QDialog*)this);
1864
1865   connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(onDeactivate()));
1866   connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(onClose()));
1867
1868   updateMainButtons();
1869   updateSelection();
1870
1871   // Initialise filter table with values of previous filter
1872   QValueList<int>::const_iterator anIter;
1873   for (anIter = theTypes.begin(); anIter != theTypes.end(); ++anIter)
1874   {
1875     myTable->Clear(*anIter);
1876     if (!myFilter[ *anIter ]->_is_nil())
1877     {
1878       SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria;
1879       if (myFilter[ *anIter ]->GetCriteria(aCriteria))
1880       {
1881         for (int i = 0, n = aCriteria->length(); i < n; i++)
1882           myTable->AddCriterion(aCriteria[ i ], *anIter);
1883       }
1884     }
1885   }
1886
1887   if (myInsertState.contains(theTypes.first()))
1888     mySetInViewer->setChecked(myInsertState[ theTypes.first() ]);
1889   else
1890     mySetInViewer->setChecked(true);
1891   if (myApplyToState.contains(theTypes.first()))
1892     mySourceGrp->setButton(myApplyToState[ theTypes.first() ]);
1893   else
1894     mySourceGrp->setButton(Selection);
1895 }
1896
1897 //=======================================================================
1898 // name    : SMESHGUI_FilterDlg::onOk
1899 // Purpose : SLOT called when "Ok" button pressed.
1900 //           Assign filters VTK viewer and close dialog
1901 //=======================================================================
1902 void SMESHGUI_FilterDlg::onOk()
1903 {
1904   if (onApply())
1905   {
1906     mySelectionMgr->clearFilters();
1907     disconnect(mySMESHGUI, 0, this, 0);
1908     disconnect(mySelectionMgr, 0, this, 0);
1909     mySMESHGUI->ResetState();
1910     accept();
1911     emit Accepted();
1912   }
1913 }
1914
1915 //=======================================================================
1916 // name    : SMESHGUI_FilterDlg::onClose
1917 // Purpose : SLOT called when "Close" button pressed. Close dialog
1918 //=======================================================================
1919 void SMESHGUI_FilterDlg::onClose()
1920 {
1921   // Restore previously selected object
1922   if (mySelectionMgr)
1923   {
1924     SALOME_ListIO aList;
1925     mySelectionMgr->clearFilters();
1926     mySelectionMgr->clearSelected();
1927     SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter (myIObjects);
1928     for (; anIter.More(); anIter.Next())
1929     {
1930       aList.Append(anIter.Key());
1931
1932       TColStd_MapOfInteger aResMap;
1933       const TColStd_IndexedMapOfInteger& anIndMap = anIter.Value();
1934       for (int i = 1, n = anIndMap.Extent(); i <= n; i++)
1935         aResMap.Add(anIndMap(i));
1936
1937       mySelector->AddOrRemoveIndex( anIter.Key(), aResMap, false);
1938       if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
1939         aViewWindow->highlight( anIter.Key(), true, true );
1940     }
1941     mySelectionMgr->setSelectedObjects(aList, false);
1942   }
1943
1944   disconnect(mySMESHGUI, 0, this, 0);
1945   disconnect(mySelectionMgr, 0, this, 0);
1946   mySMESHGUI->ResetState();
1947   reject();
1948   return;
1949 }
1950
1951 //=================================================================================
1952 // function : onHelp()
1953 // purpose  :
1954 //=================================================================================
1955 void SMESHGUI_FilterDlg::onHelp()
1956 {
1957   LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
1958   if (app)
1959     app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName);
1960   else {
1961     SUIT_MessageBox::warn1(0, QObject::tr("WRN_WARNING"),
1962                            QObject::tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
1963                            arg(app->resourceMgr()->stringValue("ExternalBrowser", "application")).arg(myHelpFileName),
1964                            QObject::tr("BUT_OK"));
1965   }
1966 }
1967
1968 //=======================================================================
1969 // name    : SMESHGUI_FilterDlg::onDeactivate
1970 // Purpose : SLOT called when dialog must be deativated
1971 //=======================================================================
1972 void SMESHGUI_FilterDlg::onDeactivate()
1973 {
1974   setEnabled(false);
1975 }
1976
1977 //=======================================================================
1978 // name    : SMESHGUI_FilterDlg::enterEvent
1979 // Purpose : Event filter
1980 //=======================================================================
1981 void SMESHGUI_FilterDlg::enterEvent (QEvent*)
1982 {
1983 //  mySMESHGUI->EmitSignalDeactivateDialog();
1984   mySMESHGUI->SetActiveDialogBox((QDialog*)this);
1985   mySMESHGUI->ResetState();
1986   setEnabled(true);
1987 }
1988
1989 //=======================================================================
1990 // name    : closeEvent()
1991 // Purpose :
1992 //=======================================================================
1993 void SMESHGUI_FilterDlg::closeEvent (QCloseEvent*)
1994 {
1995   onClose();
1996 }
1997
1998 //=======================================================================
1999 // name    : SMESHGUI_FilterDlg::getIdsFromWg
2000 // Purpose : Retrieve list of ids from given widget
2001 //=======================================================================
2002 void SMESHGUI_FilterDlg::getIdsFromWg (const QWidget* theWg, QValueList<int>& theRes) const
2003 {
2004   theRes.clear();
2005   if (theWg == 0)
2006     return;
2007
2008   if (theWg->inherits("QListBox"))
2009   {
2010     QListBox* aListBox = (QListBox*)theWg;
2011     bool b;
2012     for (int i = 0, n = aListBox->count(); i < n; i++)
2013     {
2014       int anId = aListBox->text(i).toInt(&b);
2015       if (b)
2016         theRes.append(anId);
2017     }
2018   }
2019   else if (theWg->inherits("QLineEdit"))
2020   {
2021     QLineEdit* aLineEdit = (QLineEdit*)theWg;
2022     QString aStr = aLineEdit->text();
2023     QRegExp aRegExp("(\\d+)");
2024     bool b;
2025     int aPos = 0;
2026     while (aPos >= 0)
2027     {
2028       aPos = aRegExp.search(aStr, aPos);
2029       if (aPos > -1)
2030       {
2031         int anId = aRegExp.cap(1).toInt(&b);
2032         if (b)
2033           theRes.append(anId);
2034         aPos += aRegExp.matchedLength();
2035       }
2036     }
2037   }
2038 }
2039
2040 //=======================================================================
2041 // name    : SMESHGUI_FilterDlg::getSelMode
2042 // Purpose : Get selection mode of specified type
2043 //=======================================================================
2044 Selection_Mode SMESHGUI_FilterDlg::getSelMode (const int theType) const
2045 {
2046   switch (theType)
2047   {
2048     case SMESH::NODE   : return NodeSelection;
2049     case SMESH::EDGE   : return EdgeSelection;
2050     case SMESH::FACE   : return FaceSelection;
2051     case SMESH::VOLUME : return VolumeSelection;
2052     default            : return ActorSelection;
2053   }
2054
2055 }
2056
2057 //=======================================================================
2058 // name    : SMESHGUI_FilterDlg::setIdsToWg
2059 // Purpose : Insert identifiers in specified widgets
2060 //=======================================================================
2061 void SMESHGUI_FilterDlg::setIdsToWg (QWidget* theWg, const QValueList<int>& theIds)
2062 {
2063   if (theWg == 0)
2064     return;
2065
2066   if (theWg->inherits("QListBox"))
2067   {
2068     QListBox* aListBox = (QListBox*)theWg;
2069     aListBox->clear();
2070
2071     QStringList aStrList;
2072     QValueList<int>::const_iterator anIter;
2073     for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter)
2074       aStrList.append(QString("%1").arg(*anIter));
2075
2076     aListBox->insertStringList(aStrList);
2077   }
2078   else if (theWg->inherits("QLineEdit"))
2079   {
2080     QLineEdit* aLineEdit = (QLineEdit*)theWg;
2081     QString aStr;
2082     QValueList<int>::const_iterator anIter;
2083
2084     for (anIter = theIds.begin(); anIter != theIds.end(); ++ anIter)
2085       aStr += QString("%1 ").arg(*anIter);
2086
2087     if (!aStr.isEmpty())
2088       aStr.remove(aStr.length() - 1, 1);
2089
2090     aLineEdit->setText(aStr);
2091   }
2092 }
2093
2094 //=======================================================================
2095 // name    : SMESHGUI_FilterDlg::isValid
2096 // Purpose : Verify validity of input data
2097 //=======================================================================
2098 bool SMESHGUI_FilterDlg::isValid() const
2099 {
2100   if (!myTable->IsValid())
2101     return false;
2102
2103   for (int i = 0, n = myTable->NumRows(); i < n; i++)
2104   {
2105     int aType = myTable->GetCriterionType(i);
2106     if (aType == FT_BelongToGeom ||
2107         aType == FT_BelongToPlane ||
2108         aType == FT_BelongToCylinder ||
2109         aType == FT_LyingOnGeom) {
2110       QString aName;
2111       myTable->GetThreshold(i, aName);
2112
2113       std::vector<_PTR(SObject)> aList =
2114         SMESH::GetActiveStudyDocument()->FindObjectByName(aName.latin1(), "GEOM");
2115       if (aList.size() == 0) {
2116         QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2117                                  tr("BAD_SHAPE_NAME").arg(aName), QMessageBox::Ok);
2118         return false;
2119       }
2120
2121       if (aType == FT_BelongToCylinder || aType == FT_BelongToPlane) {
2122         CORBA::Object_var anObject = SMESH::SObjectToObject(aList[ 0 ]);
2123         //GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(aList[ 0 ]->GetObject());
2124         GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(anObject);
2125         if (!aGeomObj->_is_nil()) {
2126           TopoDS_Shape aFace;
2127           if (!GEOMBase::GetShape(aGeomObj, aFace) ||
2128                aFace.IsNull() ||
2129                aFace.ShapeType() != TopAbs_FACE) {
2130             QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2131                                      tr("SHAPE_IS_NOT_A_FACE").arg(aName), QMessageBox::Ok);
2132             return false;
2133           }
2134
2135           Handle(Geom_Surface) aSurf = BRep_Tool::Surface(TopoDS::Face(aFace));
2136           if (aSurf.IsNull()) {
2137             QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2138                                      tr("SHAPE_IS_NOT_A_FACE").arg(aName), QMessageBox::Ok);
2139             return false;
2140           }
2141
2142           if (aType == FT_BelongToPlane && !aSurf->IsKind(STANDARD_TYPE(Geom_Plane))) {
2143             QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2144                                      tr("SHAPE_IS_NOT_A_PLANE").arg(aName), QMessageBox::Ok);
2145             return false;
2146           }
2147
2148           if (aType == FT_BelongToCylinder && !aSurf->IsKind(STANDARD_TYPE(Geom_CylindricalSurface))) {
2149             QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2150                                      tr("SHAPE_IS_NOT_A_CYLINDER").arg(aName), QMessageBox::Ok);
2151             return false;
2152           }
2153         }
2154       }
2155     }
2156   }
2157
2158   return true;
2159 }
2160
2161 //=======================================================================
2162 // name    : SMESHGUI_FilterDlg::SetSourceWg
2163 // Purpose : Set widget of parent dialog containing idsto be filtered if
2164 //           user select corresponding source radio button
2165 //=======================================================================
2166 void SMESHGUI_FilterDlg::SetSourceWg (QWidget* theWg)
2167 {
2168   mySourceWg = theWg;
2169 }
2170
2171 //=======================================================================
2172 // name    : SMESHGUI_FilterDlg::SetGroupIds
2173 // Purpose : Set mesh
2174 //=======================================================================
2175 void SMESHGUI_FilterDlg::SetMesh (SMESH::SMESH_Mesh_ptr theMesh)
2176 {
2177   myMesh = theMesh;
2178 }
2179
2180 //=======================================================================
2181 // name    : SMESHGUI_FilterDlg::SetSelection
2182 // Purpose : Get filtered ids
2183 //=======================================================================
2184 void SMESHGUI_FilterDlg::SetSelection()
2185 {
2186   if (mySelectionMgr)
2187     disconnect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(onSelectionDone()));
2188
2189   if (mySelectionMgr) {
2190     myIObjects.Clear();
2191     const SALOME_ListIO& anObjs = mySelector->StoredIObjects();
2192     SALOME_ListIteratorOfListIO anIter (anObjs);
2193     for (; anIter.More(); anIter.Next()) {
2194       TColStd_IndexedMapOfInteger aMap;
2195       mySelector->GetIndex(anIter.Value(), aMap);
2196       myIObjects.Bind(anIter.Value(), aMap);
2197     }
2198
2199     connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(onSelectionDone()));
2200
2201     updateSelection();
2202   }
2203   else
2204     myIObjects.Clear();
2205 }
2206
2207 //=======================================================================
2208 // name    : SMESHGUI_FilterDlg::onApply
2209 // Purpose : SLOT called when "Apply" button pressed.
2210 //           Assign filters to VTK viewer
2211 //=======================================================================
2212 bool SMESHGUI_FilterDlg::onApply()
2213 {
2214   if (!isValid())
2215     return false;
2216
2217   try {
2218     int aCurrType = myTable->GetType();
2219
2220     if (!createFilter(aCurrType))
2221       return false;
2222
2223     insertFilterInViewer();
2224
2225     if (!myFilter[ aCurrType ]->GetPredicate()->_is_nil()) {
2226       QValueList<int> aResultIds;
2227       filterSource(aCurrType, aResultIds);
2228       selectInViewer(aCurrType, aResultIds);
2229     }
2230
2231     myInsertState[ aCurrType ] = mySetInViewer->isChecked();
2232     myApplyToState[ aCurrType ] = mySourceGrp->id(mySourceGrp->selected());
2233   }
2234   catch(const SALOME::SALOME_Exception& S_ex)
2235   {
2236     SalomeApp_Tools::QtCatchCorbaException(S_ex);
2237   }
2238   catch(...)
2239   {
2240   }
2241
2242   return true;
2243 }
2244
2245 //=======================================================================
2246 // name    : SMESHGUI_FilterDlg::createFilter
2247 // Purpose : Create predicate for given type
2248 //=======================================================================
2249 bool SMESHGUI_FilterDlg::createFilter (const int theType)
2250 {
2251   SMESH::FilterManager_var aFilterMgr = SMESH::GetFilterManager();
2252   if (aFilterMgr->_is_nil())
2253     return false;
2254
2255   int n = myTable->NumRows();
2256
2257   SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria;
2258   aCriteria->length(n);
2259
2260   long aPrecision = -1;
2261   SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( mySMESHGUI );
2262
2263   if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
2264     aPrecision = mgr->integerValue( "SMESH", "controls_precision", aPrecision );
2265
2266   for (CORBA::ULong i = 0; i < n; i++) {
2267     SMESH::Filter::Criterion aCriterion = createCriterion();
2268     myTable->GetCriterion(i, aCriterion);
2269     aCriterion.Precision = aPrecision;
2270     aCriteria[ i ] = aCriterion;
2271   }
2272
2273   myFilter[ theType ] = aFilterMgr->CreateFilter();
2274   myFilter[ theType ]->SetCriteria(aCriteria.inout());
2275
2276   return true;
2277 }
2278
2279 //=======================================================================
2280 // name    : SMESHGUI_FilterDlg::insertFilterInViewer
2281 // Purpose : Insert filter in viewer
2282 //=======================================================================
2283 void SMESHGUI_FilterDlg::insertFilterInViewer()
2284 {
2285   if (SVTK_Selector* aSelector = SMESH::GetSelector()) {
2286     SMESH::ElementType anEntType = (SMESH::ElementType)myTable->GetType();
2287
2288     if (myFilter[ myTable->GetType() ]->_is_nil() ||
2289          myFilter[ myTable->GetType() ]->GetPredicate()->_is_nil() ||
2290          !mySetInViewer->isChecked()) {
2291       SMESH::RemoveFilter(getFilterId(anEntType), aSelector);
2292     }
2293     else {
2294       Handle(SMESHGUI_PredicateFilter) aFilter = new SMESHGUI_PredicateFilter();
2295       aFilter->SetPredicate(myFilter[ myTable->GetType() ]->GetPredicate());
2296       SMESH::RemoveFilter(getFilterId(anEntType), aSelector); //skl for IPAL12631
2297       SMESH::SetFilter(aFilter, aSelector);
2298     }
2299   }
2300 }
2301
2302 //=======================================================================
2303 // name    : SMESHGUI_FilterDlg::filterSource
2304 // Purpose : Filter source ids
2305 //=======================================================================
2306 void SMESHGUI_FilterDlg::filterSource (const int theType,
2307                                        QValueList<int>& theResIds)
2308 {
2309   theResIds.clear();
2310   if (myFilter[ theType ]->_is_nil())
2311     return;
2312
2313   int aSourceId = mySourceGrp->id(mySourceGrp->selected());
2314
2315   if (aSourceId == Mesh)
2316   {
2317     if (myMesh->_is_nil())
2318       return;
2319     SMESH::long_array_var anIds = myFilter[ theType ]->GetElementsId(myMesh);
2320     for (int i = 0, n = anIds->length(); i < n; i++)
2321       theResIds.append(anIds[ i ]);
2322   }
2323   else if (aSourceId == Selection)
2324   {
2325     filterSelectionSource(theType, theResIds);
2326   }
2327   else if (aSourceId == Dialog)
2328   {
2329     // retrieve ids from dialog
2330     QValueList<int> aDialogIds;
2331     getIdsFromWg(mySourceWg, aDialogIds);
2332
2333     if (myMesh->_is_nil())
2334     {
2335       theResIds = aDialogIds;
2336       return;
2337     }
2338
2339     // filter ids
2340     SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate();
2341     aPred->SetMesh(myMesh);
2342     QValueList<int>::const_iterator anIter;
2343     for (anIter = aDialogIds.begin(); anIter != aDialogIds.end(); ++ anIter)
2344       if (aPred->IsSatisfy(*anIter))
2345         theResIds.append(*anIter);
2346
2347     // set ids to the dialog
2348     setIdsToWg(mySourceWg, theResIds);
2349   }
2350 }
2351
2352 //=======================================================================
2353 // name    : SMESHGUI_FilterDlg::filterSelectionSource
2354 // Purpose : Filter source selection
2355 //=======================================================================
2356 void SMESHGUI_FilterDlg::filterSelectionSource (const int theType,
2357                                                 QValueList<int>& theResIds)
2358 {
2359   theResIds.clear();
2360   if (myMesh->_is_nil() || mySelectionMgr == 0)
2361     return;
2362
2363   // Create map of entities to be filtered
2364   TColStd_MapOfInteger aToBeFiltered;
2365   SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter(myIObjects);
2366
2367   for (; anIter.More(); anIter.Next())
2368   {
2369     // process sub mesh
2370     SMESH::SMESH_subMesh_var aSubMesh = SMESH::IObjectToInterface<SMESH::SMESH_subMesh>(anIter.Key());
2371     if (!aSubMesh->_is_nil())
2372     {
2373       if (aSubMesh->GetFather()->GetId() == myMesh->GetId())
2374       {
2375         SMESH::long_array_var anIds =
2376           theType == SMESH::NODE ? aSubMesh->GetNodesId() : aSubMesh->GetElementsId();
2377         for (int i = 0, n = anIds->length(); i < n; i++)
2378           aToBeFiltered.Add(anIds[ i ]);
2379       }
2380     }
2381
2382     // process group
2383     SMESH::SMESH_GroupBase_var aGroup =
2384       SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(anIter.Key());
2385     if (!aGroup->_is_nil())
2386     {
2387       if (aGroup->GetType() == theType && aGroup->GetMesh()->GetId() == myMesh->GetId())
2388       {
2389         SMESH::long_array_var anIds = aGroup->GetListOfID();
2390         for (int i = 0, n = anIds->length(); i < n; i++)
2391           aToBeFiltered.Add(anIds[ i ]);
2392       }
2393     }
2394
2395     // process mesh
2396     SMESH::SMESH_Mesh_var aMeshPtr = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIter.Key());
2397     if (!aMeshPtr->_is_nil() && aMeshPtr->GetId() == myMesh->GetId())
2398     {
2399       const TColStd_IndexedMapOfInteger& aSelMap = anIter.Value();
2400
2401       if (aSelMap.Extent() > 0)
2402       {
2403         if(SMESH::FindActorByEntry(anIter.Key()->getEntry()))
2404         {
2405           for (int i = 1; i <= aSelMap.Extent(); i++)
2406             aToBeFiltered.Add(aSelMap(i));
2407         }
2408       }
2409     }
2410   }
2411
2412   // Filter entities
2413   SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate();
2414   aPred->SetMesh(myMesh);
2415   TColStd_MapIteratorOfMapOfInteger aResIter(aToBeFiltered);
2416   for (; aResIter.More(); aResIter.Next())
2417     if (aPred->IsSatisfy(aResIter.Key()))
2418       theResIds.append(aResIter.Key());
2419 }
2420
2421 //=======================================================================
2422 // name    : SMESHGUI_FilterDlg::selectInViewer
2423 // Purpose : Select given entities in viewer
2424 //=======================================================================
2425 void SMESHGUI_FilterDlg::selectInViewer (const int theType, const QValueList<int>& theIds)
2426 {
2427   if (mySelectionMgr == 0 || myMesh->_is_nil())
2428     return;
2429
2430   mySelectionMgr->clearFilters();
2431
2432   // Set new selection mode if necessary
2433   Selection_Mode aSelMode = getSelMode(theType);
2434   SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );
2435   if ( aViewWindow && aViewWindow->SelectionMode()!=aSelMode) {
2436     mySelectionMgr->clearSelected();
2437     mySelectionMgr->clearFilters();
2438     if (aSelMode == NodeSelection)
2439       SMESH::SetPointRepresentation(true);
2440     aViewWindow->SetSelectionMode(aSelMode);
2441   }
2442
2443   // Clear selection
2444   SMESH_Actor* anActor = SMESH::FindActorByObject(myMesh);
2445   if (!anActor || !anActor->hasIO())
2446     return;
2447
2448   Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
2449   //mySelectionMgr->clearSelected();
2450   //mySelectionMgr->AddIObject(anIO, false);
2451   SALOME_ListIO aList;
2452   aList.Append(anIO);
2453   mySelectionMgr->setSelectedObjects(aList, false);
2454
2455   // Remove filter corresponding to the current type from viewer
2456   int aType = myTable->GetType();
2457   int aFilterId = SMESHGUI_UnknownFilter;
2458   if      (aType == SMESH::EDGE  ) aFilterId = SMESHGUI_EdgeFilter;
2459   else if (aType == SMESH::FACE  ) aFilterId = SMESHGUI_FaceFilter;
2460   else if (aType == SMESH::VOLUME) aFilterId = SMESHGUI_VolumeFilter;
2461   Handle(VTKViewer_Filter) aFilter = SMESH::GetFilter(aFilterId);
2462   SMESH::RemoveFilter(aFilterId);
2463
2464   // get vtk ids
2465   TColStd_MapOfInteger aMap;
2466   QValueList<int>::const_iterator anIter;
2467   for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter) {
2468     aMap.Add(*anIter);
2469   }
2470
2471   // Set new selection
2472   mySelector->AddOrRemoveIndex(anIO, aMap, false);
2473   if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
2474     aViewWindow->highlight( anIO, true, true );
2475
2476   // insert previously stored filter in viewer if necessary
2477   if (!aFilter.IsNull())
2478     SMESH::SetFilter(aFilter);
2479 }
2480
2481 //=======================================================================
2482 // name    : SMESHGUI_FilterDlg::createCriterion
2483 // Purpose : Create criterion structure with default values
2484 //=======================================================================
2485 SMESH::Filter::Criterion SMESHGUI_FilterDlg::createCriterion()
2486 {
2487    SMESH::Filter::Criterion aCriterion;
2488
2489   aCriterion.Type          = FT_Undefined;
2490   aCriterion.Compare       = FT_Undefined;
2491   aCriterion.Threshold     = 0;
2492   aCriterion.UnaryOp       = FT_Undefined;
2493   aCriterion.BinaryOp      = FT_Undefined;
2494   aCriterion.ThresholdStr  = "";
2495   aCriterion.ThresholdID   = "";
2496   aCriterion.TypeOfElement = SMESH::ALL;
2497
2498   return aCriterion;
2499 }
2500
2501 //=======================================================================
2502 // name    : SMESHGUI_FilterDlg::onSelectionDone
2503 // Purpose : SLOT called when selection changed.
2504 //           If current cell corresponds to the threshold value of
2505 //           BelongToGeom criterion name of selected object is set in this cell
2506 //=======================================================================
2507 void SMESHGUI_FilterDlg::onSelectionDone()
2508 {
2509   int aRow, aCol;
2510   const SALOME_ListIO& aList = mySelector->StoredIObjects();
2511
2512   if (aList.Extent() != 1 ||
2513       !myTable->CurrentCell(aRow, aCol) ||
2514       myTable->GetCriterionType(aRow) != FT_BelongToGeom &&
2515       myTable->GetCriterionType(aRow) != FT_BelongToPlane &&
2516       myTable->GetCriterionType(aRow) != FT_BelongToCylinder &&
2517       myTable->GetCriterionType(aRow) != FT_LyingOnGeom)
2518     return;
2519
2520   Handle(SALOME_InteractiveObject) anIO = aList.First();
2521   GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface<GEOM::GEOM_Object>(anIO);
2522   if (!anObj->_is_nil())
2523     {
2524       myTable->SetThreshold(aRow, GEOMBase::GetName(anObj));
2525       myTable->SetID( aRow, GEOMBase::GetIORFromObject(anObj));
2526     }
2527 }
2528
2529 //=======================================================================
2530 // name    : SMESHGUI_FilterDlg::onCriterionChanged
2531 // Purpose : SLOT called when cretarion of current row changed. Update selection
2532 //=======================================================================
2533 void SMESHGUI_FilterDlg::onCriterionChanged (const int , const int)
2534 {
2535   updateSelection();
2536 }
2537
2538 //=======================================================================
2539 // name    : SMESHGUI_FilterDlg::onCurrentChanged
2540 // Purpose : SLOT called when current row changed. Update selection
2541 //=======================================================================
2542 void SMESHGUI_FilterDlg::onCurrentChanged (int, int)
2543 {
2544   updateSelection();
2545 }
2546
2547 //=======================================================================
2548 // name    : SMESHGUI_FilterDlg::updateSelection
2549 // Purpose : UpdateSelection in accordance with current row
2550 //=======================================================================
2551 void SMESHGUI_FilterDlg::updateSelection()
2552 {
2553   if (mySelectionMgr == 0)
2554     return;
2555
2556   TColStd_MapOfInteger allTypes;
2557   for( int i=0; i<10; i++ )
2558     allTypes.Add( i );
2559   SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( mySMESHGUI->application()->activeStudy() );
2560   if( !aStudy )
2561     return;
2562
2563
2564   mySelectionMgr->clearFilters();
2565
2566   int aRow, aCol;
2567
2568   if (myTable->CurrentCell(aRow, aCol) &&
2569       (myTable->GetCriterionType(aRow) == FT_BelongToGeom ||
2570        myTable->GetCriterionType(aRow) == FT_BelongToPlane ||
2571        myTable->GetCriterionType(aRow) == FT_BelongToCylinder ||
2572        myTable->GetCriterionType(aRow) == FT_LyingOnGeom)) {
2573
2574     if (myTable->GetCriterionType(aRow) == FT_BelongToGeom ||
2575         myTable->GetCriterionType(aRow) == FT_LyingOnGeom) {
2576
2577       mySelectionMgr->installFilter(new GEOM_SelectionFilter( aStudy, true ));
2578
2579     } else if (myTable->GetCriterionType(aRow) == FT_BelongToPlane) {
2580       mySelectionMgr->installFilter(new GEOM_FaceFilter( aStudy, StdSelect_Plane ) );
2581
2582     } else if (myTable->GetCriterionType(aRow) == FT_BelongToCylinder) {
2583       mySelectionMgr->installFilter(new GEOM_FaceFilter( aStudy, StdSelect_Cylinder ) );
2584     }
2585     myIsSelectionChanged = true;
2586
2587   } else {
2588     if (myIsSelectionChanged) {
2589       mySelectionMgr->installFilter( new GEOM_TypeFilter( aStudy, -1 ) ); // This filter deactivates selection
2590     }
2591   }
2592 }
2593
2594 //=================================================================================
2595 // function : keyPressEvent()
2596 // purpose  :
2597 //=================================================================================
2598 void SMESHGUI_FilterDlg::keyPressEvent( QKeyEvent* e )
2599 {
2600   QDialog::keyPressEvent( e );
2601   if ( e->isAccepted() )
2602     return;
2603
2604   if ( e->key() == Key_F1 )
2605     {
2606       e->accept();
2607       onHelp();
2608     }
2609 }
2610