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