src/SMESHGUI/SMESHGUI_FilterDlg.cxx

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