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