src/SMESHGUI/SMESHGUI_FilterDlg.cxx

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