X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_FilterDlg.cxx;h=4e39b5da5d9a2acd1f9e31e84768304598a6248e;hp=7aeb763d3f6655cdd93c1f08f7159fe6168df0bf;hb=929ce6ba39de08a6eb9441b73d70efaf36d30260;hpb=e4737e85f0da6d3f90fd08f6be1c2825195fe16f diff --git a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx index 7aeb763d3..4e39b5da5 100755 --- a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx +++ b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx @@ -1,110 +1,144 @@ -// SMESH SMESHGUI : GUI for SMESH component +// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. // +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +// SMESH SMESHGUI : GUI for SMESH component +// File : SMESHGUI_FilterDlg.cxx +// Author : Sergey LITONIN, Open CASCADE S.A.S. // -// File : SMESHGUI_FilterDlg.cxx -// Author : Sergey LITONIN -// Module : SMESH +// SMESH includes #include "SMESHGUI_FilterDlg.h" #include "SMESHGUI.h" #include "SMESHGUI_Utils.h" #include "SMESHGUI_VTKUtils.h" -#include "SMESHGUI_FilterUtils.h" - #include "SMESHGUI_Filter.h" -#include "SMESH_Actor.h" -#include "VTKViewer_ViewFrame.h" -#include "QAD_Desktop.h" -#include "QAD_MessageBox.h" -#include "QAD_RightFrame.h" -#include "QAD_Config.h" -#include "SALOME_ListIteratorOfListIO.hxx" -#include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx" -#include "SALOMEGUI_QtCatchCorbaException.hxx" +#include "SMESHGUI_FilterUtils.h" #include "SMESHGUI_FilterLibraryDlg.h" -#include "SALOME_TypeFilter.hxx" - -#include "GEOMBase.h" -#include "GEOM_FaceFilter.hxx" +#include "SMESHGUI_SpinBox.h" -#include -#include -#include -#include +#include "SMESH_Actor.h" +#include "SMESH_NumberFilter.hxx" +#include "SMESH_TypeFilter.hxx" +#include "SMESH_LogicalFilter.hxx" + +// SALOME GEOM includes +#include +#include +#include + +// SALOME GUI includes +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +// SALOME KERNEL includes +#include +#include + +// OCCT includes +#include #include -#include #include -#include +#include #include #include +#include +#include +#include +#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define SPACING 5 -#define MARGIN 10 - -using namespace SMESH; - -static int maxLength( const QMap theMap, const QFontMetrics& theMetrics ) +// Qt includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// IDL includes +#include +#include CORBA_SERVER_HEADER(SMESH_Group) + +#define SPACING 6 +#define MARGIN 11 + +//--------------------------------------- +// maxLength +//--------------------------------------- +static int maxLength (const QMap theMap, const QFontMetrics& theMetrics) { int aRes = 0; QMap::const_iterator anIter; - for ( anIter = theMap.begin(); anIter != theMap.end(); ++anIter ) - aRes = Max( aRes, theMetrics.width( anIter.data() ) ); - return aRes; + for (anIter = theMap.begin(); anIter != theMap.end(); ++anIter) + aRes = qMax(aRes, theMetrics.width(anIter.value())); + return aRes; } -static int getFilterId( SMESH::ElementType theType ) +//--------------------------------------- +// getFilterId +//--------------------------------------- +static int getFilterId (SMESH::ElementType theType) { - switch ( theType ) + switch (theType) { - case SMESH::NODE : return SMESHGUI_NodeFilter; - case SMESH::EDGE : return SMESHGUI_EdgeFilter; - case SMESH::FACE : return SMESHGUI_FaceFilter; - case SMESH::VOLUME : return SMESHGUI_VolumeFilter; - case SMESH::ALL : return SMESHGUI_AllElementsFilter; - default : return SMESHGUI_UnknownFilter; + case SMESH::NODE : return SMESH::NodeFilter; + case SMESH::EDGE : return SMESH::EdgeFilter; + case SMESH::FACE : return SMESH::FaceFilter; + case SMESH::VOLUME : return SMESH::VolumeFilter; + case SMESH::ALL : return SMESH::AllElementsFilter; + default : return SMESH::UnknownFilter; } } @@ -113,131 +147,186 @@ static int getFilterId( SMESH::ElementType theType ) Description : Class for storing additional parameters of criterion */ -class SMESHGUI_FilterTable::AdditionalWidget : public QFrame +class SMESHGUI_FilterTable::AdditionalWidget : public QWidget { public: enum { Tolerance }; - -public: - AdditionalWidget( QWidget* theParent ); - virtual ~AdditionalWidget(); - - virtual void GetParameters( QValueList& ) const; - virtual bool IsValid( const bool theMsg = true ) const; - virtual double GetDouble( const int theId ) const; - virtual int GetInteger( const int theId ) const; - virtual QString GetString( const int theId ) const; - virtual void SetDouble( const int theId, const double theVal ); - virtual void SetInteger( const int theId, const int theVal ); - virtual void SetString( const int theId, const QString& theVal ); - void SetEditable( const int theId, const bool isEditable ); - void SetEditable( const bool isEditable ); +public: + AdditionalWidget(QWidget* theParent); + virtual ~AdditionalWidget(); + + virtual QList GetParameters() const; + virtual bool IsValid(const bool = true) const; + virtual double GetDouble(const int) const; + virtual int GetInteger(const int) const; + virtual QString GetString(const int) const; + virtual void SetDouble(const int, const double); + virtual void SetInteger(const int, const int); + virtual void SetString(const int, const QString&); + void SetEditable(const int, const bool); + void SetEditable(const bool); + void SetPrecision(const int, const char* = 0); private: - QMap< int, QLineEdit* > myLineEdits; + QMap< int, QWidget* > myWidgets; }; -SMESHGUI_FilterTable::AdditionalWidget::AdditionalWidget( QWidget* theParent ) -: QFrame( theParent ) +SMESHGUI_FilterTable::AdditionalWidget::AdditionalWidget (QWidget* theParent) + : QWidget(theParent) { - QLabel* aLabel = new QLabel( tr( "SMESH_TOLERANCE" ), this ); - myLineEdits[ Tolerance ] = new QLineEdit( this ); - QDoubleValidator* aValidator = new QDoubleValidator( myLineEdits[ Tolerance ] ); - aValidator->setBottom( 0 ); - myLineEdits[ Tolerance ]->setValidator( aValidator ); + QLabel* aLabel = new QLabel(tr("SMESH_TOLERANCE"), this); - QHBoxLayout* aLay = new QHBoxLayout( this, 0, SPACING ); - aLay->addWidget( aLabel ); - aLay->addWidget( myLineEdits[ Tolerance ] ); - - QSpacerItem* aSpacer = new QSpacerItem( 0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum ); - aLay->addItem( aSpacer ); + SMESHGUI_SpinBox* sb = new SMESHGUI_SpinBox(this); + sb->setAcceptNames( false ); // No Notebook variables allowed + sb->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) ); + sb->RangeStepAndValidator( 0., 1.e20, 0.1, "len_tol_precision" ); + myWidgets[ Tolerance ] = sb; - QString aText = QString( "%1" ).arg( Precision::Confusion() ); - myLineEdits[ Tolerance ]->setText( aText ); + QHBoxLayout* aLay = new QHBoxLayout(this); + aLay->setSpacing(SPACING); + aLay->setMargin(0); + + aLay->addWidget(aLabel); + aLay->addWidget(myWidgets[ Tolerance ]); + aLay->addStretch(); + + SetDouble( Tolerance, Precision::Confusion() ); } + SMESHGUI_FilterTable::AdditionalWidget::~AdditionalWidget() { } -void SMESHGUI_FilterTable::AdditionalWidget::GetParameters( QValueList& theList ) const +QList SMESHGUI_FilterTable::AdditionalWidget::GetParameters() const { - theList.clear(); - theList.append( Tolerance ); + QList theList; + theList.append(Tolerance); + return theList; } -bool SMESHGUI_FilterTable::AdditionalWidget::IsValid( const bool theMsg ) const +bool SMESHGUI_FilterTable::AdditionalWidget::IsValid (const bool theMsg) const { - if ( !isEnabled() ) + if (!isEnabled()) return true; - QValueList aParams; - GetParameters( aParams ); - QValueList::const_iterator anIter; - for ( anIter = aParams.begin(); anIter != aParams.end(); ++anIter ) - { - const QLineEdit* aWg = myLineEdits[ *anIter ]; - int p = 0; - QString aText = aWg->text(); - if ( aWg->isEnabled() && aWg->validator()->validate( aText, p ) != QValidator::Acceptable ) - { - if ( theMsg ) - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "SMESHGUI_INVALID_PARAMETERS" ), QMessageBox::Ok ); - return false; + QList aParams = GetParameters(); + QList::const_iterator anIter; + for (anIter = aParams.begin(); anIter != aParams.end(); ++anIter) { + if ( !myWidgets.contains( *anIter ) ) continue; + bool valid = true; + if ( qobject_cast( myWidgets[ *anIter ] ) ) { + valid = qobject_cast( myWidgets[ *anIter ] )->hasAcceptableInput(); + } + else if ( qobject_cast( myWidgets[ *anIter ] ) ) { + QString foo; + valid = qobject_cast( myWidgets[ *anIter ] )->isValid( foo, false ); + } + if (!valid && theMsg) { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("SMESHGUI_INVALID_PARAMETERS")); + return false; } } return true; } -double SMESHGUI_FilterTable::AdditionalWidget::GetDouble( const int theId ) const +double SMESHGUI_FilterTable::AdditionalWidget::GetDouble (const int theId) const +{ + double retval = 0; + if ( myWidgets.contains( theId ) ) { + if ( qobject_cast( myWidgets[ theId ] ) ) + retval = qobject_cast( myWidgets[ theId ] )->text().toDouble(); + if ( qobject_cast( myWidgets[ theId ] ) ) + retval = qobject_cast( myWidgets[ theId ] )->GetValue(); + } + return retval; +} + +int SMESHGUI_FilterTable::AdditionalWidget::GetInteger (const int theId) const { - return myLineEdits.contains( theId ) ? myLineEdits[ theId ]->text().toDouble() : 0; + int retval = 0; + if ( myWidgets.contains( theId ) ) { + if ( qobject_cast( myWidgets[ theId ] ) ) + retval = qobject_cast( myWidgets[ theId ] )->text().toInt(); + if ( qobject_cast( myWidgets[ theId ] ) ) + retval = (int)( qobject_cast( myWidgets[ theId ] )->GetValue() ); + } + return retval; } -int SMESHGUI_FilterTable::AdditionalWidget::GetInteger( const int theId ) const +QString SMESHGUI_FilterTable::AdditionalWidget::GetString (const int theId) const { - return myLineEdits.contains( theId ) ? myLineEdits[ theId ]->text().toInt() : 0; + QString retval = ""; + if ( myWidgets.contains( theId ) ) { + if ( qobject_cast( myWidgets[ theId ] ) ) + retval = qobject_cast( myWidgets[ theId ] )->text(); + if ( qobject_cast( myWidgets[ theId ] ) ) + retval = QString::number( qobject_cast( myWidgets[ theId ] )->GetValue() ); + } + return retval; } -QString SMESHGUI_FilterTable::AdditionalWidget::GetString( const int theId ) const +void SMESHGUI_FilterTable::AdditionalWidget::SetDouble (const int theId, const double theVal) { - return myLineEdits.contains( theId ) ? myLineEdits[ theId ]->text() : QString(""); + if ( myWidgets.contains( theId ) ) { + if ( qobject_cast( myWidgets[ theId ] ) ) + qobject_cast( myWidgets[ theId ] )->setText( QString::number( theVal ) ); + if ( qobject_cast( myWidgets[ theId ] ) ) + qobject_cast( myWidgets[ theId ] )->SetValue( theVal ); + } } -void SMESHGUI_FilterTable::AdditionalWidget::SetDouble( const int theId, const double theVal ) +void SMESHGUI_FilterTable::AdditionalWidget::SetInteger (const int theId, const int theVal) { - if ( myLineEdits.contains( theId ) ) - myLineEdits[ theId ]->setText( QString( "%1" ).arg( theVal ) ); + if ( myWidgets.contains( theId ) ) { + if ( qobject_cast( myWidgets[ theId ] ) ) + qobject_cast( myWidgets[ theId ] )->setText( QString::number( theVal ) ); + if ( qobject_cast( myWidgets[ theId ] ) ) + qobject_cast( myWidgets[ theId ] )->SetValue( (double)theVal ); + } } -void SMESHGUI_FilterTable::AdditionalWidget::SetInteger( const int theId, const int theVal ) +void SMESHGUI_FilterTable::AdditionalWidget::SetString (const int theId, const QString& theVal) { - if ( myLineEdits.contains( theId ) ) - myLineEdits[ theId ]->setText( QString( "%1" ).arg( theVal ) ); + if ( myWidgets.contains( theId ) ) { + if ( qobject_cast( myWidgets[ theId ] ) ) + qobject_cast( myWidgets[ theId ] )->setText( theVal ); + if ( qobject_cast( myWidgets[ theId ] ) ) + qobject_cast( myWidgets[ theId ] )->SetValue( theVal.toDouble() ); + } } -void SMESHGUI_FilterTable::AdditionalWidget::SetString( const int theId, const QString& theVal ) +void SMESHGUI_FilterTable::AdditionalWidget::SetEditable (const int theId, const bool isEditable) { - if ( myLineEdits.contains( theId ) ) - myLineEdits[ theId ]->setText( theVal ); + if ( myWidgets.contains( theId ) ) { + if ( qobject_cast( myWidgets[ theId ] ) ) + qobject_cast( myWidgets[ theId ] )->setReadOnly( !isEditable ); + if ( qobject_cast( myWidgets[ theId ] ) ) + qobject_cast( myWidgets[ theId ] )->setReadOnly( !isEditable ); + } } -void SMESHGUI_FilterTable::AdditionalWidget::SetEditable( const int theId, const bool isEditable ) +void SMESHGUI_FilterTable::AdditionalWidget::SetEditable (const bool isEditable) { - if ( myLineEdits.contains( theId ) ) - myLineEdits[ theId ]->setEdited( isEditable ); + QList aParams = GetParameters(); + QList::const_iterator anIter; + for (anIter = aParams.begin(); anIter != aParams.end(); ++anIter) + SetEditable( *anIter, isEditable ); } -void SMESHGUI_FilterTable::AdditionalWidget::SetEditable( const bool isEditable ) +void SMESHGUI_FilterTable::AdditionalWidget::SetPrecision(const int theId, const char* precision) { - QValueList aParams; - GetParameters( aParams ); - QValueList::const_iterator anIter; - for ( anIter = aParams.begin(); anIter != aParams.end(); ++anIter ) - myLineEdits[ *anIter ]->setEdited( isEditable ); + if ( myWidgets.contains( theId ) ) { + if ( qobject_cast( myWidgets[ theId ] ) ) { + SMESHGUI_SpinBox* sb = qobject_cast( myWidgets[ theId ] ); + double val = sb->GetValue(); + double min = pow(10.0, -(sb->decimals())); + sb->RangeStepAndValidator( 0., 1.e20, 0.1, precision ? precision : "len_tol_precision" ); + sb->SetValue( qMax( val, min ) ); + } + } } /* @@ -245,166 +334,529 @@ void SMESHGUI_FilterTable::AdditionalWidget::SetEditable( const bool isEditable Description : Combo table item. Identificator corresponding to string may be assigned */ -class SMESHGUI_FilterTable::ComboItem : public QComboTableItem - +class SMESHGUI_FilterTable::ComboItem : public QTableWidgetItem { public: - ComboItem( QTable*, const QMap& ); - virtual ~ComboItem(); + static int Type(); - virtual void setStringList ( const QStringList & l ); - void setStringList( const QMap& theIds ); + ComboItem( const QMap& ); + + void setItems( const QMap& ); + void clear(); + int count() const; + + int value() const; + void setValue( const int ); - int GetValue() const; - void SetValue( const int ); - private: - - QMap myNumToId; - QMap myIdToNum; + int id( int ) const; + int index( int ) const; + +private: + QMap myIdToIdx; }; -SMESHGUI_FilterTable::ComboItem::ComboItem( QTable* theParent, - const QMap& theIds ) -: QComboTableItem( theParent, QStringList() ) +int SMESHGUI_FilterTable::ComboItem::Type() { - setStringList( theIds ); + return QTableWidgetItem::UserType + 1; } -void SMESHGUI_FilterTable::ComboItem::setStringList( const QStringList & l ) +SMESHGUI_FilterTable::ComboItem::ComboItem( const QMap& theIds ) + : QTableWidgetItem( Type() ) { - QComboTableItem::setStringList( l ); + setItems( theIds ); } -void SMESHGUI_FilterTable::ComboItem::setStringList( const QMap& theIds ) +void SMESHGUI_FilterTable::ComboItem::setItems( const QMap& theIds ) { - int i = 0; - QStringList aList; - QMap::const_iterator anIter; - for ( anIter = theIds.begin(); anIter != theIds.end(); ++anIter ) - { - myNumToId[ i ] = anIter.key(); - myIdToNum[ anIter.key() ] = i; - aList.append( anIter.data() ); - i++; + myIdToIdx.clear(); + QMap::const_iterator it; + QStringList items; + for ( it = theIds.begin(); it != theIds.end(); ++it ) { + myIdToIdx[it.key()] = items.count(); + items.append( it.value() ); } + setData( Qt::UserRole, items ); + setValue( id( 0 ) ); +} + +void SMESHGUI_FilterTable::ComboItem::clear() +{ + QMap empty; + setItems( empty ); +} + +int SMESHGUI_FilterTable::ComboItem::count() const +{ + return myIdToIdx.count(); +} + +int SMESHGUI_FilterTable::ComboItem::value() const +{ + return( id( data( Qt::UserRole ).toStringList().indexOf( text() ) ) ); +} + +void SMESHGUI_FilterTable::ComboItem::setValue( const int theId ) +{ + int idx = index( theId ); + QStringList items = data( Qt::UserRole ).toStringList(); + setText( idx >= 0 && idx < items.count() ? items[idx] : "" ); +} + +int SMESHGUI_FilterTable::ComboItem::id( int idx ) const +{ + QMap::const_iterator it; + for ( it = myIdToIdx.begin(); it != myIdToIdx.end(); ++it ) + if ( it.value() == idx ) return it.key(); + return -1; +} + +int SMESHGUI_FilterTable::ComboItem::index( int i ) const +{ + return myIdToIdx.contains( i ) ? myIdToIdx[i] : -1; +} +/* + Class : SMESHGUI_FilterTable::CheckItem + Description : Check table item. +*/ + +class SMESHGUI_FilterTable::CheckItem : public QTableWidgetItem +{ +public: + static int Type(); + + CheckItem( bool = false ); + CheckItem( const QString&, bool = false ); + ~CheckItem(); + + void setChecked( bool ); + bool checked() const; +}; + +int SMESHGUI_FilterTable::CheckItem::Type() +{ + return QTableWidgetItem::UserType + 2; +} + +SMESHGUI_FilterTable::CheckItem::CheckItem( bool value ) + : QTableWidgetItem( Type() ) +{ + Qt::ItemFlags f = flags(); + f = f | Qt::ItemIsUserCheckable; + f = f & ~Qt::ItemIsTristate; + f = f & ~Qt::ItemIsEditable; + setFlags( f ); + setChecked(value); +} + +SMESHGUI_FilterTable::CheckItem::CheckItem( const QString& text, bool value ) + : QTableWidgetItem( Type() ) +{ + Qt::ItemFlags f = flags(); + f = f | Qt::ItemIsUserCheckable; + f = f & ~Qt::ItemIsTristate; + f = f & ~Qt::ItemIsEditable; + setFlags( f ); + setChecked( value ); + setText( text ); +} + +SMESHGUI_FilterTable::CheckItem::~CheckItem() +{ +} + +void SMESHGUI_FilterTable::CheckItem::setChecked( bool value ) +{ + setCheckState( value ? Qt::Checked : Qt::Unchecked ); +} + +bool SMESHGUI_FilterTable::CheckItem::checked() const +{ + return checkState() == Qt::Checked; +} + +/* + Class : SMESHGUI_FilterTable::IntSpinItem + Description : Integer spin table item. +*/ + +class SMESHGUI_FilterTable::IntSpinItem : public QTableWidgetItem +{ +public: + static int Type(); + + IntSpinItem( const int theValue ); + + int value() const; + void setValue( const int theValue ); + + void clear(); +}; + +int SMESHGUI_FilterTable::IntSpinItem::Type() +{ + return QTableWidgetItem::UserType + 3; +} + +SMESHGUI_FilterTable::IntSpinItem::IntSpinItem( const int theValue ) + : QTableWidgetItem( Type() ) +{ + setValue( theValue ); +} + +int SMESHGUI_FilterTable::IntSpinItem::value() const +{ + bool ok = false; + int value = data( Qt::UserRole ).toInt( &ok ); + return ok ? value : 0; +} + +void SMESHGUI_FilterTable::IntSpinItem::setValue( const int theValue ) +{ + setData( Qt::UserRole, theValue ); + setText( QString::number( theValue ) ); +} + +void SMESHGUI_FilterTable::IntSpinItem::clear() +{ + setText( "" ); +} + +/* + Class : SMESHGUI_FilterTable::DoubleSpinItem + Description : Double spin table item. +*/ - setStringList( aList ); +class SMESHGUI_FilterTable::DoubleSpinItem : public QTableWidgetItem +{ +public: + static int Type(); + + DoubleSpinItem( const double theValue ); + + double value() const; + void setValue( const double theValue ); + + int precision() const; + void setPrecision( const int thePrecision ); + + void clear(); +}; + +int SMESHGUI_FilterTable::DoubleSpinItem::Type() +{ + return QTableWidgetItem::UserType + 4; +} + +SMESHGUI_FilterTable::DoubleSpinItem::DoubleSpinItem( const double theValue ) + : QTableWidgetItem( Type() ) +{ + setValue( theValue ); +} + +double SMESHGUI_FilterTable::DoubleSpinItem::value() const +{ + bool ok = false; + double value = data( Qt::UserRole ).toDouble( &ok ); + return ok ? value : 0; } -SMESHGUI_FilterTable::ComboItem::~ComboItem() +void SMESHGUI_FilterTable::DoubleSpinItem::setValue( const double theValue ) +{ + setData( Qt::UserRole, theValue ); + setText( QString::number( theValue ) ); +} + +int SMESHGUI_FilterTable::DoubleSpinItem::precision() const +{ + bool ok = false; + int precision = data( Qt::UserRole + 1 ).toInt( &ok ); + return ok ? precision : 0; +} + +void SMESHGUI_FilterTable::DoubleSpinItem::setPrecision( const int thePrecision ) +{ + setData( Qt::UserRole + 1, thePrecision ); +} + +void SMESHGUI_FilterTable::DoubleSpinItem::clear() +{ + setText( "" ); +} + +/* + Class : SMESHGUI_FilterTable::ComboDelegate + Description : Table used by this widget +*/ + +class SMESHGUI_FilterTable::ComboDelegate : public QItemDelegate +{ +public: + ComboDelegate( QObject* = 0 ); + ~ComboDelegate(); + + QWidget* createEditor( QWidget*, const QStyleOptionViewItem&, + const QModelIndex& ) const; + + void setEditorData( QWidget*, const QModelIndex& ) const; + void setModelData( QWidget*, QAbstractItemModel*, const QModelIndex& ) const; + + void updateEditorGeometry( QWidget*, const QStyleOptionViewItem&, + const QModelIndex& ) const; +private: + QTableWidget* myTable; +}; + +SMESHGUI_FilterTable::ComboDelegate::ComboDelegate( QObject* parent ) + : QItemDelegate( parent ), + myTable( qobject_cast( parent ) ) { } -int SMESHGUI_FilterTable::ComboItem::GetValue() const +SMESHGUI_FilterTable::ComboDelegate::~ComboDelegate() { - return myNumToId[ currentItem() ]; } -void SMESHGUI_FilterTable::ComboItem::SetValue( const int theVal ) +QWidget* SMESHGUI_FilterTable::ComboDelegate::createEditor( QWidget* parent, + const QStyleOptionViewItem& option, + const QModelIndex& index ) const { - setCurrentItem( myIdToNum[ theVal ] ); + QVariant aData = index.data( Qt::UserRole ); + QVariant::Type aDataType = aData.type(); + if( aDataType == QVariant::StringList ) { + QStringList l = aData.toStringList(); + if ( !l.isEmpty() ) { + QComboBox* cb = new QComboBox( parent ); + cb->setFrame( false ); + cb->addItems( l ); + return cb; + } + } + else if( aDataType == QVariant::Int ) { + bool ok = false; + int aValue = aData.toInt( &ok ); + if ( ok ) { + SalomeApp_IntSpinBox* intSpin = new SalomeApp_IntSpinBox( 0, 1000, 1, parent, false, true ); + intSpin->setFrame( false ); + intSpin->setValue( aValue ); + return intSpin; + } + } + else if( aDataType == QVariant::Double ) { + bool ok = false; + double aValue = aData.toDouble( &ok ); + if ( ok ) { + int aPrecision = index.data( Qt::UserRole + 1 ).toInt( &ok ); + if ( !ok ) + aPrecision = 0; + + SalomeApp_DoubleSpinBox* dblSpin = new SalomeApp_DoubleSpinBox( -1.e20, 1.e20, 1, aPrecision, 20, parent, false, true ); + dblSpin->setFrame( false ); + dblSpin->setValue( aValue ); + return dblSpin; + } + } + return QItemDelegate::createEditor( parent, option, index ); } +void SMESHGUI_FilterTable::ComboDelegate::setEditorData( QWidget* editor, + const QModelIndex& index ) const +{ + QVariant data = index.model()->data( index, Qt::DisplayRole ); + QString value = data.toString(); + bool bOk = false; + if ( QComboBox* cb = dynamic_cast( editor ) ) { + int i = cb->findText( value ); + if ( i >= 0 ) { + cb->setCurrentIndex( i ); + bOk = true; + } + } + else if ( SalomeApp_DoubleSpinBox* dblSpin = dynamic_cast( editor ) ) { + if( data.type() == QVariant::Double ) { + double valueDouble = data.toDouble( &bOk ); + if( bOk ) + dblSpin->setValue( valueDouble ); + } + } + if ( !bOk ) QItemDelegate::setEditorData( editor, index ); +} + +void SMESHGUI_FilterTable::ComboDelegate::setModelData( QWidget* editor, + QAbstractItemModel* model, + const QModelIndex& index) const +{ + if( QComboBox* cb = dynamic_cast( editor ) ) + model->setData( index, cb->currentText(), Qt::DisplayRole ); + else if( SalomeApp_IntSpinBox* intSpin = dynamic_cast( editor ) ) + model->setData( index, intSpin->value(), Qt::DisplayRole ); + else if( SalomeApp_DoubleSpinBox* dblSpin = dynamic_cast( editor ) ) + model->setData( index, dblSpin->value(), Qt::DisplayRole ); + else QItemDelegate::setModelData( editor, model, index ); +} + +void SMESHGUI_FilterTable::ComboDelegate::updateEditorGeometry( QWidget* editor, + const QStyleOptionViewItem& option, + const QModelIndex& index ) const +{ + editor->setGeometry( option.rect ); +} /* - Class : SMESHGUI_FilterTable::Table + Class : SMESHGUI_FilterTable::Table Description : Table used by this widget */ -class SMESHGUI_FilterTable::Table : public QTable +class SMESHGUI_FilterTable::Table : public QTableWidget { public: - Table( QWidget* parent ); - Table( int numRows, int numCols, QWidget* parent = 0 ); - virtual ~Table(); + Table( QWidget* = 0 ); + Table( int, int, QWidget* = 0 ); + virtual ~Table(); + + QSize minimumSizeHint() const; + + void setEditable( bool, int, int ); + bool isEditable( int, int ) const; - void SetEditable( const bool state, const int row, const int col ); - bool IsEditable( const int row, const int col ) const; + void setReadOnly( bool ); + bool isReadOnly() const; - virtual void insertRows( int row, int count = 1 ); - virtual QString text( int row, int col ) const; + void insertRows( int, int = 1 ); + QString text( int, int ); + + QList selectedRows(); }; //======================================================================= // name : SMESHGUI_FilterTable::Table::Table // Purpose : Constructor //======================================================================= -SMESHGUI_FilterTable::Table::Table( QWidget* parent ) -: QTable( parent, "SMESHGUI_FilterTable::Table" ) +SMESHGUI_FilterTable::Table::Table (QWidget* parent) +: QTableWidget(parent) { + // set custom item delegate + setItemDelegate( new ComboDelegate(this) ); + // set edit triggers by default + setReadOnly( false ); } -SMESHGUI_FilterTable::Table::Table( int numRows, int numCols, QWidget* parent ) -: QTable( numRows, numCols, parent, "SMESHGUI_FilterTable::Table" ) +//======================================================================= +// name : SMESHGUI_FilterTable::Table::Table +// Purpose : Constructor +//======================================================================= +SMESHGUI_FilterTable::Table::Table (int numRows, int numCols, QWidget* parent) +: QTableWidget(numRows, numCols, parent) { + // set custom item delegate + setItemDelegate( new ComboDelegate(this) ); + // set edit triggers by default + setReadOnly( false ); } +//======================================================================= +// name : SMESHGUI_FilterTable::Table::~Table +// Purpose : Destructor +//======================================================================= SMESHGUI_FilterTable::Table::~Table() { } //======================================================================= -// name : SMESHGUI_FilterTable::Table::SetEditable +// name : SMESHGUI_FilterTable::Table::minimumSizeHint +// Purpose : Get minimum size for the table +//======================================================================= +QSize SMESHGUI_FilterTable::Table::minimumSizeHint() const +{ + QSize s = QTableWidget::minimumSizeHint(); + QHeaderView* hv = horizontalHeader(); + if ( hv ) + s.setWidth( qMax( s.width(), hv->length() ) ); + return s; +} + +//======================================================================= +// name : SMESHGUI_FilterTable::Table::setEditable // Purpose : Set editable of specified cell //======================================================================= -void SMESHGUI_FilterTable::Table::SetEditable( const bool isEditable, const int row, const int col ) +void SMESHGUI_FilterTable::Table::setEditable (bool isEditable, + int row, int col) { - QTableItem* anItem = item( row, col ); - if( anItem ) - takeItem( anItem ); + QTableWidgetItem* anItem = item( row, col ); + if ( anItem ) { + bool isSignalsBlocked = signalsBlocked(); + blockSignals( true ); - if ( !isEditable ) - setItem( row, col, new QTableItem( this, QTableItem::Never, "" ) ); - else - setItem( row, col, new QTableItem( this, QTableItem::OnTyping, "" ) ); + Qt::ItemFlags f = anItem->flags(); + if ( !isEditable ) f = f & ~Qt::ItemIsEditable; + else f = f | Qt::ItemIsEditable; + anItem->setFlags( f ); + + blockSignals( isSignalsBlocked ); + } } //======================================================================= -// name : SMESHGUI_FilterTable::Table::IsEditable +// name : SMESHGUI_FilterTable::Table::isEditable // Purpose : Verify wheter cell is editable //======================================================================= -bool SMESHGUI_FilterTable::Table::IsEditable( const int row, const int col ) const +bool SMESHGUI_FilterTable::Table::isEditable (int row, int col) const { - QTableItem* anItem = item( row, col ); - return anItem == 0 || anItem->editType() != QTableItem::Never; + QTableWidgetItem* anItem = item( row, col ); + return anItem == 0 || anItem->flags() & Qt::ItemIsEditable; +} + +void SMESHGUI_FilterTable::Table::setReadOnly( bool on ) +{ + setEditTriggers( on ? + QAbstractItemView::NoEditTriggers : + QAbstractItemView::AllEditTriggers ); +} + +bool SMESHGUI_FilterTable::Table::isReadOnly() const +{ + return editTriggers() == QAbstractItemView::NoEditTriggers; } //======================================================================= // name : SMESHGUI_FilterTable::Table::insertRows -// Purpose : Insert rows ( virtual redefined ) +// Purpose : Insert rows (virtual redefined) //======================================================================= -void SMESHGUI_FilterTable::Table::insertRows( int row, int count ) +void SMESHGUI_FilterTable::Table::insertRows (int row, int count) { - int anEditRow = currEditRow(); - int anEditCol = currEditCol(); - - if ( anEditRow >= 0 && anEditCol >= 0 ) - endEdit( anEditRow, anEditCol, true, false ); - - QTable::insertRows( row, count ); + closePersistentEditor( currentItem() ); + while ( count-- ) insertRow( row ); } //======================================================================= // name : SMESHGUI_FilterTable::Table::text -// Purpose : Get text from cell ( virtual redefined ) +// Purpose : Get text from cell (virtual redefined) //======================================================================= -QString SMESHGUI_FilterTable::Table::text( int row, int col ) const +QString SMESHGUI_FilterTable::Table::text (int row, int col) { - int anEditRow = currEditRow(); - int anEditCol = currEditCol(); - - if ( anEditRow >= 0 && anEditCol >= 0 && anEditRow == row && anEditCol == col ) - ((Table*)this)->endEdit( row, col, true, false ); - - return QTable::text( row, col ); + closePersistentEditor( currentItem() ); + QTableWidgetItem* anItem = item( row, col ); + return anItem ? anItem->text() : QString(); } +QList SMESHGUI_FilterTable::Table::selectedRows() +{ + QList selItems = selectedItems(); + QTableWidgetItem* anItem; + QList rows; + + foreach( anItem, selItems ) { + int r = row( anItem ); + if ( !rows.contains( r ) ) rows.append( r ); + } + qSort( rows ); + return rows; +} /* Class : SMESHGUI_FilterTable - Description : Frame containig + Description : Frame containig - Button group for switching entity type - Table for displaying filter criterions - Buttons for editing table and filter libraries @@ -414,181 +866,205 @@ QString SMESHGUI_FilterTable::Table::text( int row, int col ) const // name : SMESHGUI_FilterTable::SMESHGUI_FilterTable // Purpose : Constructor //======================================================================= -SMESHGUI_FilterTable::SMESHGUI_FilterTable( QWidget* parent, +SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule, + QWidget* parent, const int type ) -: QFrame( parent ) +: QWidget( parent ), + myIsLocked( false ), + mySMESHGUI( theModule ) { myEntityType = -1; - Init( type ); -} + + QList aTypes; + aTypes.append(type); + Init(aTypes); +} //======================================================================= // name : SMESHGUI_FilterTable::SMESHGUI_FilterTable // Purpose : Constructor //======================================================================= -SMESHGUI_FilterTable::SMESHGUI_FilterTable( QWidget* parent, - const QValueList& types ) -: QFrame( parent ) +SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule, + QWidget* parent, + const QList& types ) +: QWidget( parent ), + myIsLocked( false ), + mySMESHGUI( theModule ) { myEntityType = -1; - Init( types ); -} - -SMESHGUI_FilterTable::~SMESHGUI_FilterTable() -{ + Init(types); } -//======================================================================= -// name : SMESHGUI_FilterTable::Init -// Purpose : Create table corresponding to the specified type -//======================================================================= -void SMESHGUI_FilterTable::Init( const int type ) +SMESHGUI_FilterTable::~SMESHGUI_FilterTable() { - QValueList aTypes; - aTypes.append( type ); - Init( aTypes ); } //======================================================================= // name : SMESHGUI_FilterTable::Init // Purpose : Create table corresponding to the specified type //======================================================================= -void SMESHGUI_FilterTable::Init( const QValueList& theTypes ) +void SMESHGUI_FilterTable::Init (const QList& theTypes) { - if ( theTypes.isEmpty() ) + if (theTypes.isEmpty()) return; - + // Create buttons if necessary - - if ( myTables.isEmpty() ) - { - int aType = theTypes.first(); + if (myTables.isEmpty()) + { // create main layout - QVBoxLayout* aMainLay = new QVBoxLayout( this ); - QGroupBox* aMainGrp = new QGroupBox( 1, Qt::Horizontal, this ); - aMainGrp->setFrameStyle( QFrame::NoFrame ); - aMainGrp->setInsideMargin( 0 ); - aMainLay->addWidget( aMainGrp ); - + QVBoxLayout* aMainLay = new QVBoxLayout(this); + aMainLay->setMargin( 0 ); + aMainLay->setSpacing( SPACING ); + // create switch of entity types - myEntityTypeGrp = new QButtonGroup( 1, Qt::Vertical, tr( "ENTITY_TYPE" ), aMainGrp ); + myEntityTypeBox = new QGroupBox(tr("ENTITY_TYPE"), this); + QHBoxLayout* myEntityTypeBoxLayout = new QHBoxLayout(myEntityTypeBox); + myEntityTypeBoxLayout->setMargin( MARGIN ); + myEntityTypeBoxLayout->setSpacing( SPACING ); + myEntityTypeGrp = new QButtonGroup(this); + const QMap& aSupportedTypes = getSupportedTypes(); QMap::const_iterator anIter; - for ( anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter ) + for (anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter) { - QRadioButton* aBtn = new QRadioButton( anIter.data(), myEntityTypeGrp ); - myEntityTypeGrp->insert( aBtn, anIter.key() ); + QRadioButton* aBtn = new QRadioButton(anIter.value(), myEntityTypeBox); + myEntityTypeGrp->addButton(aBtn, anIter.key()); + myEntityTypeBoxLayout->addWidget(aBtn); } - myTableGrp = new QGroupBox( 1, Qt::Horizontal, tr( "FILTER" ), aMainGrp ); - QFrame* aTableFrame = new QFrame( myTableGrp ); - + myTableGrp = new QGroupBox(tr("FILTER"), this ); + // create table - mySwitchTableGrp = new QGroupBox( 1, Qt::Horizontal, aTableFrame ); - mySwitchTableGrp->setFrameStyle( QFrame::NoFrame ); - mySwitchTableGrp->setInsideMargin( 0 ); - - myTables[ aType ] = createTable( mySwitchTableGrp, aType ); - + mySwitchTableGrp = new QWidget(myTableGrp); + QVBoxLayout* mySwitchTableGrpLayout = new QVBoxLayout(mySwitchTableGrp); + mySwitchTableGrpLayout->setMargin(0); + mySwitchTableGrpLayout->setSpacing(0); + + QList::const_iterator typeIt = theTypes.begin(); + for ( ; typeIt != theTypes.end(); ++typeIt ) { + Table* aTable = createTable(mySwitchTableGrp, *typeIt); + myTables[ *typeIt ] = aTable; + mySwitchTableGrpLayout->addWidget(aTable); + if ( typeIt != theTypes.begin() ) + aTable->hide(); + } + // create buttons - myAddBtn = new QPushButton( tr( "ADD" ), aTableFrame ); - myRemoveBtn = new QPushButton( tr( "REMOVE" ), aTableFrame ); - myClearBtn = new QPushButton( tr( "CLEAR" ), aTableFrame ); - myInsertBtn = new QPushButton( tr( "INSERT" ), aTableFrame ); - myCopyFromBtn = new QPushButton( tr( "COPY_FROM" ), aTableFrame ); - myAddToBtn = new QPushButton( tr( "ADD_TO" ), aTableFrame ); - - myAddBtn->setAutoDefault( false ); - myRemoveBtn->setAutoDefault( false ); - myClearBtn->setAutoDefault( false ); - myInsertBtn->setAutoDefault( false ); - myCopyFromBtn->setAutoDefault( false ); - myAddToBtn->setAutoDefault( false ); + myAddBtn = new QPushButton(tr("ADD"), myTableGrp); + myRemoveBtn = new QPushButton(tr("REMOVE"), myTableGrp); + myClearBtn = new QPushButton(tr("CLEAR"), myTableGrp); + myInsertBtn = new QPushButton(tr("INSERT"), myTableGrp); + myCopyFromBtn = new QPushButton(tr("COPY_FROM"), myTableGrp); + myAddToBtn = new QPushButton(tr("ADD_TO"), myTableGrp); + + myAddBtn->setAutoDefault(false); + myRemoveBtn->setAutoDefault(false); + myClearBtn->setAutoDefault(false); + myInsertBtn->setAutoDefault(false); + myCopyFromBtn->setAutoDefault(false); + myAddToBtn->setAutoDefault(false); myCopyFromBtn->hide(); myAddToBtn->hide(); - + // layout widgets - QGridLayout* aLay = new QGridLayout( aTableFrame, 8, 2, 0, SPACING ); - - aLay->addMultiCellWidget( mySwitchTableGrp, 0, 6, 0, 0 ); - aLay->addWidget( myAddBtn, 0, 1 ); - aLay->addWidget( myInsertBtn, 1, 1 ); - aLay->addWidget( myRemoveBtn, 2, 1 ); - aLay->addWidget( myClearBtn, 3, 1 ); - aLay->addWidget( myCopyFromBtn, 5, 1 ); - aLay->addWidget( myAddToBtn, 6, 1 ); - aLay->addMultiCellWidget( createAdditionalFrame( aTableFrame ), 7, 7, 0, 1 ); - - aLay->setColStretch( 0, 1 ); - aLay->setColStretch( 1, 0 ); - - QSpacerItem* aVSpacer = new QSpacerItem( 0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding ); - aLay->addItem( aVSpacer, 4, 1 ); + QGridLayout* aLay = new QGridLayout(myTableGrp); + aLay->setMargin(MARGIN); + aLay->setSpacing(SPACING); + + aLay->addWidget(mySwitchTableGrp, 0, 0, 7, 1); + aLay->addWidget(myAddBtn, 0, 1); + aLay->addWidget(myInsertBtn, 1, 1); + aLay->addWidget(myRemoveBtn, 2, 1); + aLay->addWidget(myClearBtn, 3, 1); + aLay->addWidget(myCopyFromBtn, 5, 1); + aLay->addWidget(myAddToBtn, 6, 1); + aLay->addWidget(createAdditionalFrame(myTableGrp), 7, 0, 1, 2 ); + + aLay->setRowMinimumHeight(4, 10); + aLay->setRowStretch(4, 1); + aLay->setColumnStretch(0, 1); + aLay->setColumnStretch(1, 0); + + // layout + aMainLay->addWidget(myEntityTypeBox); + aMainLay->addWidget(myTableGrp); // signals and slots - connect( myAddBtn, SIGNAL( clicked() ), this, SLOT( onAddBtn() ) ); - connect( myInsertBtn, SIGNAL( clicked() ), this, SLOT( onInsertBtn() ) ); - connect( myRemoveBtn, SIGNAL( clicked() ), this, SLOT( onRemoveBtn() ) ); - connect( myClearBtn, SIGNAL( clicked() ), this, SLOT( onClearBtn() ) ); - - connect( myCopyFromBtn, SIGNAL( clicked() ), this, SLOT( onCopyFromBtn() ) ); - connect( myAddToBtn, SIGNAL( clicked() ), this, SLOT( onAddToBtn() ) ); - - connect( myEntityTypeGrp, SIGNAL( clicked( int ) ), this, SLOT( onEntityType( int ) ) ); - + connect(myAddBtn, SIGNAL(clicked()), this, SLOT(onAddBtn())); + connect(myInsertBtn, SIGNAL(clicked()), this, SLOT(onInsertBtn())); + connect(myRemoveBtn, SIGNAL(clicked()), this, SLOT(onRemoveBtn())); + connect(myClearBtn, SIGNAL(clicked()), this, SLOT(onClearBtn())); + + connect(myCopyFromBtn, SIGNAL(clicked()), this, SLOT(onCopyFromBtn())); + connect(myAddToBtn, SIGNAL(clicked()), this, SLOT(onAddToBtn())); + + connect(myEntityTypeGrp, SIGNAL(buttonClicked(int)), this, SLOT(onEntityType(int))); + myLibDlg = 0; } - + else + { + QList::const_iterator typeIt = theTypes.begin(); + for ( ; typeIt != theTypes.end(); ++typeIt ) { + if ( !myTables[ *typeIt ] ) { + Table* aTable = createTable(mySwitchTableGrp, *typeIt); + myTables[ *typeIt ] = aTable; + ((QVBoxLayout*)mySwitchTableGrp->layout())->addWidget(myTables[ *typeIt ]); + } + } + } + // Hide buttons of entity types if necessary const QMap& aSupportedTypes = getSupportedTypes(); QMap::const_iterator anIt; - for ( anIt = aSupportedTypes.begin(); anIt != aSupportedTypes.end(); ++anIt ) + for (anIt = aSupportedTypes.begin(); anIt != aSupportedTypes.end(); ++anIt) { - QButton* aBtn = myEntityTypeGrp->find( anIt.key() ); - theTypes.contains( anIt.key() ) ? aBtn->show() : aBtn->hide(); + QAbstractButton* aBtn = myEntityTypeGrp->button(anIt.key()); + if ( aBtn ) aBtn->setVisible( theTypes.contains(anIt.key()) ); } // select first button if there is no selected buttons or it is hidden - QButton* aBtn = myEntityTypeGrp->selected(); - if ( aBtn == 0 || theTypes.find( myEntityTypeGrp->id( aBtn ) ) == theTypes.end() ) - myEntityTypeGrp->setButton( theTypes.first() ); + int aBtnId = myEntityTypeGrp->checkedId(); + if ( aBtnId == -1 || !theTypes.contains(aBtnId) ) { + QAbstractButton* aBtn = myEntityTypeGrp->button(theTypes.first()); + if ( aBtn ) aBtn->setChecked(true); + } - if ( theTypes.count() == 1 ) - myEntityTypeGrp->hide(); - else - myEntityTypeGrp->show(); + myEntityTypeBox->setVisible(theTypes.count() > 1); myTableGrp->updateGeometry(); - int aType = myEntityTypeGrp->id( myEntityTypeGrp->selected() ); - onEntityType( aType ); + int cType = myEntityTypeGrp->checkedId(); + onEntityType(cType); } //======================================================================= -// name : SMESHGUI_FilterTable::GetTableGrp +// name : SMESHGUI_FilterTable::createAdditionalFrame // Purpose : Get group box containing table. May be used for adding new widgets in it -////======================================================================= -QWidget* SMESHGUI_FilterTable::createAdditionalFrame( QWidget* theParent ) +//======================================================================= +QWidget* SMESHGUI_FilterTable::createAdditionalFrame (QWidget* theParent) { - QFrame* aFrame = new QFrame( theParent ); - - QFrame* aLine1 = new QFrame( aFrame ); - QFrame* aLine2 = new QFrame( aFrame ); - aLine1->setFrameStyle( QFrame::HLine | QFrame::Sunken ); - aLine2->setFrameStyle( QFrame::HLine | QFrame::Sunken ); - aLine1->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed) ); - aLine2->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed) ); - - QLabel* aLabel = new QLabel( tr( "ADDITIONAL_PARAMETERS" ), aFrame ); + QWidget* aFrame = new QWidget(theParent); + + QFrame* aLine1 = new QFrame(aFrame); + QFrame* aLine2 = new QFrame(aFrame); + aLine1->setFrameStyle(QFrame::HLine | QFrame::Sunken); + aLine2->setFrameStyle(QFrame::HLine | QFrame::Sunken); + aLine1->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + aLine2->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + + QLabel* aLabel = new QLabel(tr("ADDITIONAL_PARAMETERS"), aFrame); - myWgStack = new QWidgetStack( aFrame ); + myWgStack = new QStackedWidget(aFrame); - QGridLayout* aLay = new QGridLayout( aFrame, 2, 3, 0, SPACING ); - aLay->addWidget( aLine1, 0, 0 ); - aLay->addWidget( aLabel, 0, 1 ); - aLay->addWidget( aLine2, 0, 2 ); - aLay->addMultiCellWidget( myWgStack, 1, 1, 0, 2 ); + QGridLayout* aLay = new QGridLayout(aFrame); + aLay->setMargin(0); + aLay->setSpacing(SPACING); + aLay->addWidget(aLine1, 0, 0); + aLay->addWidget(aLabel, 0, 1); + aLay->addWidget(aLine2, 0, 2); + aLay->addWidget(myWgStack, 1, 0, 1, 3); return aFrame; } @@ -596,7 +1072,7 @@ QWidget* SMESHGUI_FilterTable::createAdditionalFrame( QWidget* theParent ) //======================================================================= // name : SMESHGUI_FilterTable::GetTableGrp // Purpose : Get group box containing table. May be used for adding new widgets in it -////======================================================================= +//======================================================================= QGroupBox* SMESHGUI_FilterTable::GetTableGrp() { return myTableGrp; @@ -605,92 +1081,94 @@ QGroupBox* SMESHGUI_FilterTable::GetTableGrp() //======================================================================= // name : SMESHGUI_FilterTable::onEntityType // Purpose : SLOT. Called when entity type changed. -// Display corresponding table +// Display corresponding table //======================================================================= -void SMESHGUI_FilterTable::onEntityType( int theType ) +void SMESHGUI_FilterTable::onEntityType (int theType) { - if ( myEntityType == theType ) + if (myEntityType == theType) return; myIsValid = true; emit NeedValidation(); - if ( !myIsValid ) + if (!myIsValid) { - myEntityTypeGrp->setButton( myEntityType ); + myEntityTypeGrp->button(myEntityType)->setChecked(true); return; } myEntityType = theType; - - if ( !myTables.contains( theType ) ) - myTables[ theType ] = createTable( mySwitchTableGrp, theType ); - + + if (!myTables.contains(theType)) { + myTables[ theType ] = createTable(mySwitchTableGrp, theType); + ((QVBoxLayout*)mySwitchTableGrp->layout())->addWidget(myTables[ theType ]); + } + TableMap::iterator anIter; - for ( anIter = myTables.begin(); anIter != myTables.end(); ++anIter ) - myEntityType == anIter.key() ? anIter.data()->show() : anIter.data()->hide(); + for (anIter = myTables.begin(); anIter != myTables.end(); ++anIter) + anIter.value()->setVisible( myEntityType == anIter.key() ); updateBtnState(); qApp->processEvents(); myTables[ myEntityType ]->updateGeometry(); adjustSize(); - emit EntityTypeChanged( theType ); - + emit EntityTypeChanged(theType); } //======================================================================= // name : SMESHGUI_FilterTable::IsValid // Purpose : Verify validity of entered data //======================================================================= -bool SMESHGUI_FilterTable::IsValid( const bool theMess, const int theEntityType ) const +bool SMESHGUI_FilterTable::IsValid (const bool theMess, const int theEntityType) const { int aType = theEntityType == -1 ? GetType() : theEntityType; Table* aTable = myTables[ aType ]; - for ( int i = 0, n = aTable->numRows(); i < n; i++ ) + for (int i = 0, n = aTable->rowCount(); i < n; i++) { - int aCriterion = GetCriterionType( i, aType ); - - if ( aCriterion == FT_RangeOfIds || - aCriterion == FT_BelongToGeom || - aCriterion == FT_BelongToPlane || - aCriterion == FT_BelongToCylinder ) + int aCriterion = GetCriterionType(i, aType); + QString errMsg; + if (aCriterion == SMESH::FT_GroupColor ) { - if ( aTable->text( i, 2 ).isEmpty() ) - { - if ( theMess ) - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "ERROR" ), QMessageBox::Ok ); - return false; - } + QtxColorButton* clrBtn = qobject_cast(aTable->cellWidget(i, 2)); + if (clrBtn && !clrBtn->color().isValid()) + errMsg = tr( "GROUPCOLOR_ERROR" ); } - else + else if (aCriterion == SMESH::FT_RangeOfIds || + aCriterion == SMESH::FT_BelongToMeshGroup || + aCriterion == SMESH::FT_BelongToGeom || + aCriterion == SMESH::FT_BelongToPlane || + aCriterion == SMESH::FT_BelongToCylinder || + aCriterion == SMESH::FT_BelongToGenSurface || + aCriterion == SMESH::FT_ElemGeomType || + aCriterion == SMESH::FT_EntityType || + aCriterion == SMESH::FT_CoplanarFaces || + aCriterion == SMESH::FT_LyingOnGeom || + aCriterion == SMESH::FT_ConnectedElements ) + { + if (aTable->text(i, 2).isEmpty()) + errMsg = tr( "ERROR" ); + } + else // check correctness of a numeric value { bool aRes = false; - aTable->blockSignals( true ); - double aThreshold = ( int )aTable->text( i, 2 ).toDouble( &aRes ); - aTable->blockSignals( false ); + bool isSignalsBlocked = aTable->signalsBlocked(); + aTable->blockSignals(true); + double aThreshold = (int)aTable->text(i, 2).toDouble(&aRes); + aTable->blockSignals(isSignalsBlocked); - if ( !aRes && aTable->IsEditable( i, 2 ) ) - { - if ( theMess ) - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "ERROR" ), QMessageBox::Ok ); - return false; - } - else if ( aType == SMESH::EDGE && - GetCriterionType( i, aType ) == SMESH::FT_MultiConnection && - aThreshold == 1 ) - { - if ( theMess ) - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "MULTIEDGES_ERROR" ), QMessageBox::Ok ); - return false; - } + if (!aRes && aTable->isEditable(i, 2)) + errMsg = tr( "ERROR" ); + } + + if (!errMsg.isEmpty()) { + if (theMess) + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), errMsg ); + return false; } - QTableItem* anItem = aTable->item( i, 0 ); - if ( myAddWidgets.contains( anItem ) && !myAddWidgets[ anItem ]->IsValid() ) + QTableWidgetItem* anItem = aTable->item(i, 0); + if (myAddWidgets.contains(anItem) && !myAddWidgets[ anItem ]->IsValid()) return false; } @@ -701,7 +1179,7 @@ bool SMESHGUI_FilterTable::IsValid( const bool theMess, const int theEntityType // name : SMESHGUI_FilterTable::SetValidity // Purpose : Set validity of the table //======================================================================= -void SMESHGUI_FilterTable::SetValidity( const bool isValid ) +void SMESHGUI_FilterTable::SetValidity (const bool isValid) { myIsValid = isValid; } @@ -719,10 +1197,10 @@ int SMESHGUI_FilterTable::GetType() const // name : SMESHGUI_FilterTable::SetType // Purpose : Set current entity type //======================================================================= -void SMESHGUI_FilterTable::SetType( const int type ) +void SMESHGUI_FilterTable::SetType (const int type) { - myEntityTypeGrp->setButton( type ); - onEntityType( type ); + myEntityTypeGrp->button(type)->setChecked(true); + onEntityType(type); } //======================================================================= @@ -731,108 +1209,229 @@ void SMESHGUI_FilterTable::SetType( const int type ) //======================================================================= void SMESHGUI_FilterTable::RestorePreviousEntityType() { - SetType( myEntityType ); + SetType(myEntityType); } //======================================================================= // name : SMESHGUI_FilterTable::GetCriterionType -// Purpose : Get type of criterion from specified row ( corresponding enums in h-file ) +// Purpose : Get type of criterion from specified row (corresponding enums in h-file) //======================================================================= -int SMESHGUI_FilterTable::GetCriterionType( const int theRow, const int theType ) const +int SMESHGUI_FilterTable::GetCriterionType (const int theRow, const int theType) const { int aType = theType == -1 ? GetType() : theType; Table* aTable = myTables[ aType ]; - ComboItem* anItem = (ComboItem*)aTable->item( theRow, 0 ); - return anItem != 0 ? anItem->GetValue() : FT_Undefined; + ComboItem* anItem = (ComboItem*)aTable->item(theRow, 0); + return anItem != 0 ? anItem->value() : SMESH::FT_Undefined; } //======================================================================= // name : SMESHGUI_FilterTable::GetCriterion // Purpose : Get parameters of criterion from specified row //======================================================================= -void SMESHGUI_FilterTable::GetCriterion( const int theRow, +void SMESHGUI_FilterTable::GetCriterion (const int theRow, SMESH::Filter::Criterion& theCriterion, - const int theEntityType ) const + const int theEntityType) const { int aType = theEntityType == -1 ? GetType() : theEntityType; Table* aTable = myTables[ aType ]; - - theCriterion.Type = ( (ComboItem*)aTable->item( theRow, 0 ) )->GetValue(); - theCriterion.UnaryOp = ( (QCheckTableItem*)aTable->item( theRow, 3 ) )->isChecked() ? FT_LogicalNOT : FT_Undefined; - theCriterion.BinaryOp = theRow != aTable->numRows() - 1 ? - ( (ComboItem*)aTable->item( theRow, 4 ) )->GetValue() : FT_Undefined; - theCriterion.TypeOfElement = (ElementType)aType; - int aCriterionType = GetCriterionType( theRow, aType ); + theCriterion.Type = ((ComboItem*)aTable->item(theRow, 0))->value(); + theCriterion.UnaryOp = ((CheckItem*)aTable->item(theRow, 3))->checked() ? SMESH::FT_LogicalNOT : SMESH::FT_Undefined; + theCriterion.BinaryOp = theRow != aTable->rowCount() - 1 ? + ((ComboItem*)aTable->item(theRow, 4))->value() : SMESH::FT_Undefined; + theCriterion.TypeOfElement = (SMESH::ElementType)aType; + + int aCriterionType = GetCriterionType(theRow, aType); - if ( aCriterionType != FT_RangeOfIds && - aCriterionType != FT_BelongToGeom && - aCriterionType != FT_BelongToPlane && - aCriterionType != FT_BelongToCylinder ) + if ( aCriterionType == SMESH::FT_GroupColor ) + { + QtxColorButton* clrBtn = qobject_cast(aTable->cellWidget(theRow, 2)); + if ( clrBtn ) + { + Kernel_Utils::Localizer loc; + const QColor qClr = clrBtn->color(); + QString clrStr = QString( "%1;%2;%3" ). + arg( qClr.red()/256. ).arg( qClr.green()/256. ).arg( qClr.blue()/256. ); + theCriterion.ThresholdStr = clrStr.toLatin1().constData(); + } + } + else if ( aCriterionType == SMESH::FT_ElemGeomType || + aCriterionType == SMESH::FT_EntityType ) { - theCriterion.Compare = ( (ComboItem*)aTable->item( theRow, 1 ) )->GetValue(); - theCriterion.Threshold = aTable->item( theRow, 2 )->text().toDouble(); + theCriterion.Threshold = (double)((ComboItem*)aTable->item(theRow, 2))->value(); + } + else if ( aCriterionType == SMESH::FT_CoplanarFaces ) + { + theCriterion.ThresholdID = aTable->text(theRow, 2).toLatin1().constData(); + } + else if ( aCriterionType == SMESH::FT_ConnectedElements ) + { + QString id = aTable->text(theRow, 5); + if ( !id.isEmpty() ) // shape ID + { + theCriterion.ThresholdID = id.toLatin1().constData(); + } + else + { + QString text = aTable->text(theRow, 2).trimmed(); + QString workText = text; + for ( char c = '0'; c <= '9'; ++c ) + workText.remove( c ); + + if ( workText.isEmpty() ) // node ID + theCriterion.Threshold = text.toDouble(); + else // point coordinates + theCriterion.ThresholdStr = text.toLatin1().constData(); + } + } + else if ( aCriterionType != SMESH::FT_RangeOfIds && + aCriterionType != SMESH::FT_BelongToMeshGroup && + aCriterionType != SMESH::FT_BelongToGeom && + aCriterionType != SMESH::FT_BelongToPlane && + aCriterionType != SMESH::FT_BelongToCylinder && + aCriterionType != SMESH::FT_BelongToGenSurface && + aCriterionType != SMESH::FT_LyingOnGeom ) + { + theCriterion.Compare = ((ComboItem*)aTable->item(theRow, 1))->value(); + theCriterion.Threshold = aTable->item(theRow, 2)->text().toDouble(); } else - theCriterion.ThresholdStr = aTable->text( theRow, 2 ).latin1(); + { + theCriterion.ThresholdStr = aTable->text(theRow, 2).toLatin1().constData(); + if ( aCriterionType != SMESH::FT_RangeOfIds ) + theCriterion.ThresholdID = aTable->text( theRow, 5 ).toLatin1().constData(); + } - QTableItem* anItem = aTable->item( theRow, 0 ); - if ( myAddWidgets.contains( anItem ) ) - theCriterion.Tolerance = myAddWidgets[ anItem ]->GetDouble( AdditionalWidget::Tolerance ); + QTableWidgetItem* anItem = aTable->item(theRow, 0); + if (myAddWidgets.contains(anItem)) + theCriterion.Tolerance = myAddWidgets[ anItem ]->GetDouble(AdditionalWidget::Tolerance); } //======================================================================= // name : SMESHGUI_FilterTable::SetCriterion // Purpose : Set parameters of criterion of specified row //======================================================================= -void SMESHGUI_FilterTable::SetCriterion( const int theRow, +void SMESHGUI_FilterTable::SetCriterion (const int theRow, const SMESH::Filter::Criterion& theCriterion, - const int theEntityType ) + const int theEntityType) { int aType = theEntityType == -1 ? GetType() : theEntityType; Table* aTable = myTables[ aType ]; - if ( theRow > aTable->numRows() - 1 ) + if (theRow > aTable->rowCount() - 1) return; - ( (ComboItem*)aTable->item( theRow, 0 ) )->SetValue( theCriterion.Type ); - onCriterionChanged( theRow, 0, aType ); - ( (ComboItem*)aTable->item( theRow, 1 ) )->SetValue( theCriterion.Compare ); - ( (QCheckTableItem*)aTable->item( theRow, 3 ) )->setChecked( theCriterion.UnaryOp == FT_LogicalNOT ); + ((ComboItem*)aTable->item(theRow, 0))->setValue(theCriterion.Type); + onCriterionChanged(theRow, 0, aType); + if ( theCriterion.Compare == SMESH::FT_Undefined ) + ((ComboItem*)aTable->item(theRow, 1))->setValue( SMESH::FT_EqualTo ); + else + ((ComboItem*)aTable->item(theRow, 1))->setValue(theCriterion.Compare); + ((CheckItem*)aTable->item(theRow, 3))->setChecked(theCriterion.UnaryOp == SMESH::FT_LogicalNOT); - if ( theCriterion.BinaryOp != FT_Undefined ) + if (theCriterion.BinaryOp != SMESH::FT_Undefined) { - if ( !aTable->IsEditable( theRow, 4 ) ) - aTable->setItem( theRow, 4, getBinaryItem( aTable ) ); - ( (ComboItem*)aTable->item( theRow, 4 ) )->SetValue( theCriterion.BinaryOp ); + if (!aTable->isEditable(theRow, 4)) + aTable->setItem(theRow, 4, getBinaryItem()); + ((ComboItem*)aTable->item(theRow, 4))->setValue(theCriterion.BinaryOp); } else - aTable->SetEditable( false, theRow, 4 ); + aTable->setEditable(false, theRow, 4); - if ( theCriterion.Type != FT_RangeOfIds && - theCriterion.Type != FT_BelongToGeom && - theCriterion.Type != FT_BelongToPlane && - theCriterion.Type != FT_BelongToCylinder ) - aTable->setText( theRow, 2, QString( "%1" ).arg( theCriterion.Threshold, 0, 'g', 15 ) ); + if (theCriterion.Type == SMESH::FT_GroupColor ) + { + QtxColorButton* clrBtn = qobject_cast(aTable->cellWidget(theRow, 2)); + if ( clrBtn ) + { + QColor qClr; + QString clrStr( theCriterion.ThresholdStr ); + QStringList clrVals = clrStr.split( ";" ); + if ( clrVals.count() > 2 ) + qClr.setRgb( (int)256*clrVals[0].toDouble(), + (int)256*clrVals[1].toDouble(), + (int)256*clrVals[2].toDouble() ); + clrBtn->setColor( qClr ); + } + } + else if (theCriterion.Type == SMESH::FT_ElemGeomType || + theCriterion.Type == SMESH::FT_EntityType ) + { + ComboItem* typeBox = (ComboItem*)aTable->item(theRow, 2); + typeBox->setValue( (int)(theCriterion.Threshold + 0.5) ); + } + else if (theCriterion.Type == SMESH::FT_CoplanarFaces ) + { + aTable->item( theRow, 2 )->setText( QString( theCriterion.ThresholdID ) ); + } + else if (theCriterion.Type == SMESH::FT_ConnectedElements ) + { + if ( strlen( theCriterion.ThresholdID ) > 0 ) // shape ID -> name + { + _PTR(SObject) sobj = + SMESH::GetActiveStudyDocument()->FindObjectID( theCriterion.ThresholdID.in() ); + if ( !sobj ) + aTable->item( theRow, 2 )->setText( QString( theCriterion.ThresholdID ) ); + else + aTable->item( theRow, 2 )->setText( QString( sobj->GetName().c_str() )); + } + else if ( strlen( theCriterion.ThresholdStr ) > 0 ) // point coords + { + aTable->item( theRow, 2 )->setText( QString( theCriterion.ThresholdStr )); + } + else // node ID + { + aTable->item( theRow, 2 )->setText( QString("%1").arg((int) theCriterion.Threshold )); + } + } + else if (theCriterion.Type != SMESH::FT_RangeOfIds && + theCriterion.Type != SMESH::FT_BelongToMeshGroup && + theCriterion.Type != SMESH::FT_BelongToGeom && + theCriterion.Type != SMESH::FT_BelongToPlane && + theCriterion.Type != SMESH::FT_BelongToCylinder && + theCriterion.Type != SMESH::FT_BelongToGenSurface && + theCriterion.Type != SMESH::FT_LyingOnGeom && + theCriterion.Type != SMESH::FT_FreeBorders && + theCriterion.Type != SMESH::FT_FreeEdges && + theCriterion.Type != SMESH::FT_FreeNodes && + theCriterion.Type != SMESH::FT_FreeFaces && + theCriterion.Type != SMESH::FT_BadOrientedVolume && + theCriterion.Type != SMESH::FT_BareBorderFace && + theCriterion.Type != SMESH::FT_BareBorderVolume && + theCriterion.Type != SMESH::FT_OverConstrainedFace && + theCriterion.Type != SMESH::FT_OverConstrainedVolume && + theCriterion.Type != SMESH::FT_LinearOrQuadratic) + { + // Numberic criterion + aTable->item( theRow, 2 )->setText(QString("%1").arg(theCriterion.Threshold, 0, 'g', 15)); + } else - aTable->setText( theRow, 2, QString( theCriterion.ThresholdStr ) ); + { + aTable->item( theRow, 2 )->setText(QString(theCriterion.ThresholdStr)); + if ( theCriterion.Type != SMESH::FT_RangeOfIds ) + aTable->item( theRow, 5 )->setText( QString( theCriterion.ThresholdID ) ); + } - if ( theCriterion.Compare == FT_EqualTo || - theCriterion.Type == FT_BelongToPlane || - theCriterion.Type == FT_BelongToCylinder ) + if (theCriterion.Compare == SMESH::FT_EqualTo || + theCriterion.Type == SMESH::FT_BelongToPlane || + theCriterion.Type == SMESH::FT_BelongToCylinder || + theCriterion.Type == SMESH::FT_BelongToGenSurface || + theCriterion.Type == SMESH::FT_BelongToGeom || + theCriterion.Type == SMESH::FT_LyingOnGeom || + theCriterion.Type == SMESH::FT_CoplanarFaces || + theCriterion.Type == SMESH::FT_EqualNodes) { - QTableItem* anItem = aTable->item( theRow, 0 ); - if ( !myAddWidgets.contains( anItem ) ) + QTableWidgetItem* anItem = aTable->item(theRow, 0); + if (!myAddWidgets.contains(anItem)) { - myAddWidgets[ anItem ] = new AdditionalWidget( myWgStack ); - myWgStack->addWidget( myAddWidgets[ anItem ] ); + myAddWidgets[ anItem ] = new AdditionalWidget(myWgStack); + myAddWidgets[ anItem ]->SetPrecision( AdditionalWidget::Tolerance, getPrecision( theCriterion.Type ) ); + myWgStack->addWidget(myAddWidgets[ anItem ]); } - myAddWidgets[ anItem ]->SetDouble( AdditionalWidget::Tolerance, theCriterion.Tolerance ); + myAddWidgets[ anItem ]->SetDouble(AdditionalWidget::Tolerance, theCriterion.Tolerance); } - emit CretarionChanged( theRow, aType ); - + emit CriterionChanged(theRow, aType); } //======================================================================= @@ -843,9 +1442,9 @@ void SMESHGUI_FilterTable::Update() { Table* aTable = myTables[ GetType() ]; int aCurrRow = aTable->currentRow(); - int numRows = aTable->numRows(); - if ( ( aCurrRow < 0 || aCurrRow >= numRows ) && numRows > 0 ) - aTable->setCurrentCell( 0, 0 ); + int numRows = aTable->rowCount(); + if ((aCurrRow < 0 || aCurrRow >= numRows) && numRows > 0) + aTable->setCurrentCell(0, 0); updateAdditionalWidget(); } @@ -853,40 +1452,40 @@ void SMESHGUI_FilterTable::Update() // name : SMESHGUI_FilterTable::AddCriterion // Purpose : Add criterion with parameters //======================================================================= -void SMESHGUI_FilterTable::AddCriterion( const SMESH::Filter::Criterion& theCriterion, - const int theEntityType ) +void SMESHGUI_FilterTable::AddCriterion (const SMESH::Filter::Criterion& theCriterion, + const int theEntityType) { int aType = theEntityType == -1 ? GetType() : theEntityType; Table* aTable = myTables[ aType ]; - addRow( aTable, aType ); - SetCriterion( aTable->numRows() - 1, theCriterion ); + addRow(aTable, aType); + SetCriterion(aTable->rowCount() - 1, theCriterion); } //======================================================================= // name : SMESHGUI_FilterTable::NumRows // Purpose : Get number of criterions of current type //======================================================================= -int SMESHGUI_FilterTable::NumRows( const int theEntityType ) const +int SMESHGUI_FilterTable::NumRows (const int theEntityType) const { - return myTables[ theEntityType == -1 ? GetType() : theEntityType ]->numRows(); + return myTables[ theEntityType == -1 ? GetType() : theEntityType ]->rowCount(); } //======================================================================= // name : SMESHGUI_FilterTable::Clear // Purpose : Clear current table //======================================================================= -void SMESHGUI_FilterTable::Clear( const int theType ) +void SMESHGUI_FilterTable::Clear (const int theType) { int aType = theType == -1 ? GetType() : theType; - QTable* aTable = myTables[ aType ]; + Table* aTable = myTables[ aType ]; - if ( aTable->numRows() == 0 ) + if (aTable->rowCount() == 0) return; - while ( aTable->numRows() > 0 ) + while (aTable->rowCount() > 0) { - removeAdditionalWidget( aTable, 0 ); - aTable->removeRow( 0 ); + removeAdditionalWidget(aTable, 0); + aTable->removeRow(0); } updateBtnState(); @@ -900,9 +1499,8 @@ void SMESHGUI_FilterTable::Clear( const int theType ) void SMESHGUI_FilterTable::onAddBtn() { int aType = GetType(); - addRow( myTables[ aType ], aType ); + addRow(myTables[ aType ], aType); - Table* aTable = myTables[ aType ]; Update(); } @@ -913,7 +1511,7 @@ void SMESHGUI_FilterTable::onAddBtn() //======================================================================= void SMESHGUI_FilterTable::onInsertBtn() { - addRow( myTables[ GetType() ], GetType(), false ); + addRow(myTables[ GetType() ], GetType(), false); } //======================================================================= @@ -925,25 +1523,22 @@ void SMESHGUI_FilterTable::onRemoveBtn() { Table* aTable = myTables[ GetType() ]; - if ( aTable->numRows() == 0 ) + if (aTable->rowCount() == 0) return; - QMemArray aRows; - for ( int i = 0, n = aTable->numRows(); i < n; i++ ) + QList items = aTable->selectedItems(); + + QList aRows = aTable->selectedRows(); // already sorted + int i; + foreach( i, aRows ) { - if ( aTable->isRowSelected( i ) ) - { - aRows.resize( aRows.size() + 1 ); - aRows[ aRows.size() - 1 ] = i; - removeAdditionalWidget( aTable, i ); - } + removeAdditionalWidget(aTable, i); + aTable->removeRow(i); } - aTable->removeRows( aRows ); - // remove control of binary logical operation from last row - if ( aTable->numRows() > 0 ) - aTable->SetEditable( false, aTable->numRows() - 1, 4 ); + if (aTable->rowCount() > 0) + aTable->setEditable(false, aTable->rowCount() - 1, 4); updateBtnState(); } @@ -956,25 +1551,82 @@ void SMESHGUI_FilterTable::updateAdditionalWidget() { Table* aTable = myTables[ GetType() ]; int aRow = aTable->currentRow(); - if ( aRow < 0 || aRow >= aTable->numRows() ) + if (aRow < 0 || aRow >= aTable->rowCount()) { - myWgStack->setEnabled( false ); + myWgStack->setEnabled(false); return; } - ComboItem* anItem = ( (ComboItem*)aTable->item( aRow, 0 ) ); - bool toEnable = ( (ComboItem*)aTable->item( aRow, 1 ) )->GetValue() == FT_EqualTo && - GetCriterionType( aRow ) != FT_BelongToGeom && - GetCriterionType( aRow ) != FT_RangeOfIds && - GetCriterionType( aRow ) != FT_FreeEdges; - if ( !myAddWidgets.contains( anItem ) ) - { - myAddWidgets[ anItem ] = new AdditionalWidget( myWgStack ); - myWgStack->addWidget( myAddWidgets[ anItem ] ); - } - - myWgStack->raiseWidget( myWgStack->id( myAddWidgets[ anItem ] ) ); - myWgStack->setEnabled( toEnable ); + ComboItem* anItem = ((ComboItem*)aTable->item(aRow, 0)); + int aCriterion = GetCriterionType(aRow); + bool isDbl = ( aCriterion == SMESH::FT_AspectRatio || + aCriterion == SMESH::FT_AspectRatio3D || + aCriterion == SMESH::FT_Warping || + aCriterion == SMESH::FT_MinimumAngle || + aCriterion == SMESH::FT_Taper || + aCriterion == SMESH::FT_Skew || + aCriterion == SMESH::FT_Area || + aCriterion == SMESH::FT_Volume3D || + aCriterion == SMESH::FT_MaxElementLength2D || + aCriterion == SMESH::FT_MaxElementLength3D || + aCriterion == SMESH::FT_Length || + aCriterion == SMESH::FT_Length2D || + aCriterion == SMESH::FT_BallDiameter ); + + bool toEnable = (( isDbl && ((ComboItem*)aTable->item(aRow, 1))->value() == SMESH::FT_EqualTo) || + aCriterion == SMESH::FT_BelongToPlane || + aCriterion == SMESH::FT_BelongToCylinder || + aCriterion == SMESH::FT_BelongToGenSurface || + aCriterion == SMESH::FT_BelongToGeom || + aCriterion == SMESH::FT_LyingOnGeom || + aCriterion == SMESH::FT_CoplanarFaces || + aCriterion == SMESH::FT_EqualNodes); + + if (!myAddWidgets.contains(anItem)) + { + myAddWidgets[ anItem ] = new AdditionalWidget(myWgStack); + myWgStack->addWidget(myAddWidgets[ anItem ]); + } + + myWgStack->setCurrentWidget(myAddWidgets[ anItem ]); + myAddWidgets[ anItem ]->SetPrecision( AdditionalWidget::Tolerance, getPrecision( aCriterion ) ); + myWgStack->setEnabled(toEnable); +} + +const char* SMESHGUI_FilterTable::getPrecision( const int aType ) +{ + const char* retval = 0; + switch ( aType ) { + case SMESH::FT_AspectRatio: + case SMESH::FT_AspectRatio3D: + case SMESH::FT_Taper: + retval = "parametric_precision"; break; + case SMESH::FT_Warping: + case SMESH::FT_MinimumAngle: + case SMESH::FT_Skew: + case SMESH::FT_CoplanarFaces: + retval = "angle_precision"; break; + case SMESH::FT_Area: + retval = "area_precision"; break; + case SMESH::FT_BelongToGeom: + case SMESH::FT_BelongToPlane: + case SMESH::FT_BelongToCylinder: + case SMESH::FT_BelongToGenSurface: + case SMESH::FT_LyingOnGeom: + case SMESH::FT_EqualNodes: + retval = "len_tol_precision"; break; + case SMESH::FT_Length: + case SMESH::FT_Length2D: + case SMESH::FT_MaxElementLength2D: + case SMESH::FT_MaxElementLength3D: + case SMESH::FT_BallDiameter: + retval = "length_precision"; break; + case SMESH::FT_Volume3D: + retval = "vol_precision"; break; + default: + break; + } + return retval; } //======================================================================= @@ -982,15 +1634,15 @@ void SMESHGUI_FilterTable::updateAdditionalWidget() // Purpose : Remove widgets containing additional parameters from widget // stack and internal map //======================================================================= -void SMESHGUI_FilterTable::removeAdditionalWidget( QTable* theTable, const int theRow ) +void SMESHGUI_FilterTable::removeAdditionalWidget (QTableWidget* theTable, const int theRow) { - QTableItem* anItem = theTable->item( theRow, 0 ); - if ( myAddWidgets.contains( anItem ) ) + QTableWidgetItem* anItem = theTable->item(theRow, 0); + if (myAddWidgets.contains(anItem)) { - myWgStack->removeWidget( myAddWidgets[ anItem ] ); - myAddWidgets[ anItem ]->reparent( 0, QPoint() ); + myWgStack->removeWidget(myAddWidgets[ anItem ]); + myAddWidgets[ anItem ]->setParent(0); delete myAddWidgets[ anItem ]; - myAddWidgets.remove( anItem ); + myAddWidgets.remove(anItem); } } @@ -1001,15 +1653,15 @@ void SMESHGUI_FilterTable::removeAdditionalWidget( QTable* theTable, const int t //======================================================================= void SMESHGUI_FilterTable::onClearBtn() { - QTable* aTable = myTables[ GetType() ]; + Table* aTable = myTables[ GetType() ]; - if ( aTable->numRows() == 0 ) + if (aTable->rowCount() == 0) return; - while ( aTable->numRows() > 0 ) + while (aTable->rowCount() > 0) { - removeAdditionalWidget( aTable, 0 ); - aTable->removeRow( 0 ); + removeAdditionalWidget(aTable, 0); + aTable->removeRow(0); } updateBtnState(); @@ -1019,61 +1671,336 @@ void SMESHGUI_FilterTable::onClearBtn() // name : SMESHGUI_FilterTable::onCurrentChanged() // Purpose : SLOT. Called when current cell changed //======================================================================= -void SMESHGUI_FilterTable::onCurrentChanged( int theRow, int theCol ) +void SMESHGUI_FilterTable::onCurrentChanged (int theRow, int theCol) { - updateAdditionalWidget(); - emit CurrentChanged( theRow, theCol ); + if( !myIsLocked ) + updateAdditionalWidget(); + emit CurrentChanged(theRow, theCol); +} + +//======================================================================= +// name : geomTypes +// Purpose : returns available geometry types of elements +//======================================================================= +static QList geomTypes( const int theType ) +{ + QList typeIds; + if ( theType == SMESH::NODE ) + typeIds.append( SMESH::Geom_POINT ); + if ( theType == SMESH::ALL || theType == SMESH::EDGE ) + typeIds.append( SMESH::Geom_EDGE ); + if ( theType == SMESH::ALL || theType == SMESH::FACE ) + { + typeIds.append( SMESH::Geom_TRIANGLE ); + typeIds.append( SMESH::Geom_QUADRANGLE ); + typeIds.append( SMESH::Geom_POLYGON ); + } + if ( theType == SMESH::ALL || theType == SMESH::VOLUME ) + { + typeIds.append( SMESH::Geom_TETRA ); + typeIds.append( SMESH::Geom_PYRAMID ); + typeIds.append( SMESH::Geom_HEXA ); + typeIds.append( SMESH::Geom_PENTA ); + typeIds.append( SMESH::Geom_HEXAGONAL_PRISM ); + typeIds.append( SMESH::Geom_POLYHEDRA ); + } + if ( theType == SMESH::ALL || theType == SMESH::ELEM0D ) + { + typeIds.append( SMESH::Geom_POINT ); + } + if ( theType == SMESH::ALL || theType == SMESH::BALL ) + { + typeIds.append( SMESH::Geom_BALL ); + } + return typeIds; +} + +//======================================================================= +// name : entityTypes +// Purpose : returns available entity types of elements +//======================================================================= + +static QList entityTypes( const int theType ) +{ + QList typeIds; + + switch ( theType ) + { + case SMESH::NODE: + typeIds.append( SMDSEntity_Node ); + case SMESH::EDGE: + typeIds.append( SMDSEntity_Edge ); + typeIds.append( SMDSEntity_Quad_Edge ); + break; + case SMESH::FACE: + typeIds.append( SMDSEntity_Triangle ); + typeIds.append( SMDSEntity_Quad_Triangle ); + typeIds.append( SMDSEntity_BiQuad_Triangle ); + typeIds.append( SMDSEntity_Quadrangle ); + typeIds.append( SMDSEntity_Quad_Quadrangle ); + typeIds.append( SMDSEntity_BiQuad_Quadrangle ); + typeIds.append( SMDSEntity_Polygon ); + //typeIds.append( SMDSEntity_Quad_Polygon ); + break; + case SMESH::VOLUME: + typeIds.append( SMDSEntity_Tetra ); + typeIds.append( SMDSEntity_Quad_Tetra ); + typeIds.append( SMDSEntity_Pyramid ); + typeIds.append( SMDSEntity_Quad_Pyramid ); + typeIds.append( SMDSEntity_Hexa ); + typeIds.append( SMDSEntity_Quad_Hexa ); + typeIds.append( SMDSEntity_TriQuad_Hexa ); + typeIds.append( SMDSEntity_Penta ); + typeIds.append( SMDSEntity_Quad_Penta ); + typeIds.append( SMDSEntity_Hexagonal_Prism ); + typeIds.append( SMDSEntity_Polyhedra ); + //typeIds.append( SMDSEntity_Quad_Polyhedra ); + break; + case SMESH::ELEM0D: + typeIds.append( SMDSEntity_0D ); + break; + case SMESH::BALL: + typeIds.append( SMDSEntity_Ball ); + break; + } + return typeIds; } //======================================================================= // name : SMESHGUI_FilterTable::onCriterionChanged() // Purpose : Provides reaction on change of criterion //======================================================================= -void SMESHGUI_FilterTable::onCriterionChanged( const int row, const int col, const int entityType ) + +void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int entityType) { int aType = entityType == -1 ? GetType() : entityType; Table* aTable = myTables[ aType ]; - ComboItem* aCompareItem = (ComboItem*)aTable->item( row, 1 ); + ComboItem* aCompareItem = (ComboItem*)aTable->item(row, 1); + + // find out type of a existing threshould table item + QtxColorButton* clrBtn = qobject_cast(aTable->cellWidget(row, 2)); + bool isComboItem = false; + bool isIntSpinItem = false; + bool isDoubleSpinItem = false; + if ( QTableWidgetItem* aTableItem = aTable->item(row, 2) ) + { + int aTableType = aTableItem->type(); + isComboItem = ( aTableType == ComboItem::Type() ); + isIntSpinItem = ( aTableType == IntSpinItem::Type() ); + isDoubleSpinItem = ( aTableType == DoubleSpinItem::Type() ); + } + + // find out a type of item required by a new criterion and other table features + int aCriterionType = GetCriterionType(row); + bool anIsDoubleCriterion = false; + bool anIsIntCriterion = false; + bool anIsComboCriterion = false; + // other features: + QList comboIDs; // values to show in a combo item + int nbCompareSigns = 0; // possible values are 0,1,3 + bool isThresholdEditable = false; // actual for "simple" item types + switch ( aCriterionType ) + { + case SMESH::FT_AspectRatio: + case SMESH::FT_AspectRatio3D: + case SMESH::FT_Warping: + case SMESH::FT_MinimumAngle: + case SMESH::FT_Taper: + case SMESH::FT_Skew: + case SMESH::FT_Area: + case SMESH::FT_Volume3D: + case SMESH::FT_MaxElementLength2D: + case SMESH::FT_MaxElementLength3D: + anIsDoubleCriterion = true; break; + + case SMESH::FT_FreeBorders: + case SMESH::FT_FreeEdges: + case SMESH::FT_FreeNodes: + case SMESH::FT_FreeFaces: + case SMESH::FT_EqualNodes: + case SMESH::FT_EqualEdges: + case SMESH::FT_EqualFaces: + case SMESH::FT_EqualVolumes: break; + + case SMESH::FT_MultiConnection: + case SMESH::FT_MultiConnection2D: anIsIntCriterion = true; nbCompareSigns = 3; break; + + case SMESH::FT_Length: + case SMESH::FT_Length2D: anIsDoubleCriterion = true; break; + + case SMESH::FT_BelongToMeshGroup: break; + + case SMESH::FT_BelongToGeom: + case SMESH::FT_BelongToPlane: + case SMESH::FT_BelongToCylinder: + case SMESH::FT_BelongToGenSurface: + case SMESH::FT_LyingOnGeom: nbCompareSigns = 0; isThresholdEditable = true; break; + + case SMESH::FT_RangeOfIds: nbCompareSigns = 0; isThresholdEditable = true; break; + + case SMESH::FT_BadOrientedVolume: + case SMESH::FT_BareBorderVolume: + case SMESH::FT_BareBorderFace: + case SMESH::FT_OverConstrainedVolume: + case SMESH::FT_OverConstrainedFace: + case SMESH::FT_LinearOrQuadratic: break; + + case SMESH::FT_GroupColor: nbCompareSigns = 1; isThresholdEditable = true; break; + + case SMESH::FT_ElemGeomType: + comboIDs = geomTypes( aType ); anIsComboCriterion = true; nbCompareSigns = 1; break; + + case SMESH::FT_EntityType: + comboIDs = entityTypes( aType ); anIsComboCriterion = true; nbCompareSigns = 1; break; + + case SMESH::FT_CoplanarFaces: isThresholdEditable = true; break; + + case SMESH::FT_BallDiameter: anIsDoubleCriterion = true; break; + + case SMESH::FT_ConnectedElements: isThresholdEditable = true; break; + + case SMESH::FT_LessThan: + case SMESH::FT_MoreThan: + case SMESH::FT_EqualTo: + case SMESH::FT_LogicalNOT: + case SMESH::FT_LogicalAND: + case SMESH::FT_LogicalOR: + case SMESH::FT_Undefined: + default: return; + } + + // get a precision of a double criterion + int aPrecision = 0; + if ( anIsDoubleCriterion ) { + const char* aPrecisionType = getPrecision( aCriterionType ); + SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr( mySMESHGUI ); + if( aPrecisionType && aResourceMgr ) + aPrecision = aResourceMgr->integerValue( "SMESH", aPrecisionType, aPrecision ); + } + + // check if the current item type satisfies the criterion + bool itemTypeKO = + ( aCriterionType == SMESH::FT_GroupColor && !clrBtn) || + ( anIsComboCriterion && !isComboItem ) || + ( anIsIntCriterion && !isIntSpinItem ) || + ( anIsDoubleCriterion && !isDoubleSpinItem ); + + if ( !itemTypeKO ) + { + if ( anIsDoubleCriterion ) + { + // if the precision is to be changed we should remove the existing + // spin item and create another one with new precision + if ( DoubleSpinItem* aDoubleSpinItem = dynamic_cast( aTable->item( row, 2 ))) + itemTypeKO = ( aDoubleSpinItem->precision() != aPrecision ); + else + itemTypeKO = true; + } + else if ( anIsComboCriterion ) + { + if ( ComboItem* aComboItem = dynamic_cast( aTable->item( row, 2 ))) + itemTypeKO = ( aComboItem->count() != comboIDs.count() ); + else + itemTypeKO = true; + } + else if ( !anIsIntCriterion && aCriterionType != SMESH::FT_GroupColor ) + { + itemTypeKO = ( clrBtn || isComboItem || isIntSpinItem || isDoubleSpinItem ); + } + } - int aCriterionType = GetCriterionType( row ); + // update the table row - if ( aType == SMESH::EDGE && aCriterionType == SMESH::FT_FreeBorders || - aType == SMESH::FACE && aCriterionType == SMESH::FT_FreeEdges ) - { - if ( aCompareItem->count() > 0 ) - aCompareItem->setStringList( QStringList() ); - aTable->SetEditable( false, row, 2 ); - } - else if ( aCriterionType == SMESH::FT_RangeOfIds || - aCriterionType == SMESH::FT_BelongToGeom || - aCriterionType == SMESH::FT_BelongToPlane || - aCriterionType == SMESH::FT_BelongToCylinder ) + bool isSignalsBlocked = aTable->signalsBlocked(); + aTable->blockSignals( true ); + + // update threshold table item + if ( itemTypeKO ) { - QMap aMap; - aMap[ FT_EqualTo ] = tr( "EQUAL_TO" ); - aCompareItem->setStringList( aMap ); - if ( !aTable->IsEditable( row, 2 ) ) - aTable->SetEditable( true, row, 2 ); + aTable->removeCellWidget( row, 2 ); + + if ( aCriterionType == SMESH::FT_GroupColor ) // ---------------------- QtxColorButton + { + aTable->setCellWidget( row, 2, new QtxColorButton( aTable ) ); + } + else if ( anIsComboCriterion ) // -------------------------------------------ComboItem + { + QString msgPrefix + ( aCriterionType == SMESH::FT_ElemGeomType ? "GEOM_TYPE_%1" : "ENTITY_TYPE_%1" ); + QMap names; + QList::const_iterator id = comboIDs.begin(); + for ( ; id != comboIDs.end(); ++id ) + { + QString name = msgPrefix.arg( *id ); + names[ *id ] = tr( name.toLatin1().data() ); + } + ComboItem* comboBox = new ComboItem( names ); + aTable->setItem( row, 2, comboBox ); + } + else if ( anIsIntCriterion ) // ------------------------------------------ IntSpinItem + { + IntSpinItem* intSpin = new IntSpinItem( 0 ); + aTable->setItem( row, 2, intSpin ); + } + else if ( anIsDoubleCriterion ) // -------------------------------------DoubleSpinItem + { + DoubleSpinItem* dblSpin = new DoubleSpinItem( 0 ); + dblSpin->setPrecision( aPrecision ); + aTable->setItem( row, 2, dblSpin ); + } + else // --------------------------------------------------------------QTableWidgetItem + { + aTable->setItem( row, 2, new QTableWidgetItem() ); + } } - else + + // set Compare + if ( anIsDoubleCriterion ) + nbCompareSigns = 3; + if ( aCompareItem->count() != nbCompareSigns ) { - if ( aCompareItem->count() != 3 ) - { - aCompareItem->setStringList( QStringList() ); - aCompareItem->setStringList( getCompare() ); + switch ( nbCompareSigns ) { + case 0: { + aCompareItem->clear(); + break; + } + case 1: { + QMap aMap; + aMap[ SMESH::FT_EqualTo ] = tr("EQUAL_TO"); + aCompareItem->setItems(aMap); + break; } + case 3: { + int oldValue = aCompareItem->value(); + aCompareItem->setItems(getCompare()); + if ( oldValue >= 0 ) + aCompareItem->setValue( oldValue ); + break; + } + } + } + aTable->setEditable( nbCompareSigns == 3, row, 1); - QString aText = aTable->text( row, 2 ); - bool isOk = false; - aText.toDouble( &isOk ); - aTable->setText( row, 2, isOk ? aText : QString("") ); - if ( !aTable->IsEditable( row, 2 ) ) - aTable->SetEditable( true, row, 2 ); + // enable/desable Threshold + if ( aCriterionType == SMESH::FT_GroupColor || + anIsComboCriterion || + anIsIntCriterion || + anIsDoubleCriterion ) + { + isThresholdEditable = true; + } + if ( !isThresholdEditable ) + { + aTable->setItem( row, 2, new QTableWidgetItem() ); } + aTable->setEditable( isThresholdEditable, row, 2); + + + aTable->blockSignals( isSignalsBlocked ); updateAdditionalWidget(); - - emit CretarionChanged( row, entityType ); + + emit CriterionChanged(row, entityType); } //======================================================================= @@ -1081,9 +2008,12 @@ void SMESHGUI_FilterTable::onCriterionChanged( const int row, const int col, con // Purpose : SLOT. Called then contents of table changed // Provides reaction on change of criterion //======================================================================= -void SMESHGUI_FilterTable::onCriterionChanged( int row, int col ) +void SMESHGUI_FilterTable::onCriterionChanged (int row, int col) { - onCriterionChanged( row, col, -1 ); + if( col == 0 ) + onCriterionChanged(row, col, -1); + else if ( col == 2 ) + emit ThresholdChanged(row, GetType()); } //======================================================================= @@ -1092,73 +2022,83 @@ void SMESHGUI_FilterTable::onCriterionChanged( int row, int col ) //======================================================================= int SMESHGUI_FilterTable::getFirstSelectedRow() const { - QTable* aTable = myTables[ GetType() ]; - for ( int i = 0, n = aTable->numRows(); i < n; i++ ) - if ( aTable->isRowSelected( i ) ) - return i; + Table* aTable = myTables[ GetType() ]; - int aRow = aTable->currentRow(); - return aRow >= 0 && aRow < aTable->numRows() ? aRow : -1; + QList selRows = aTable->selectedRows(); // already sorted + int aRow = selRows.count() > 0 ? selRows[0] : aTable->currentRow(); + + return aRow >= 0 && aRow < aTable->rowCount() ? aRow : -1; } //======================================================================= // name : SMESHGUI_FilterTable::addRow // Purpose : Add row at the end of table //======================================================================= -void SMESHGUI_FilterTable::addRow( Table* theTable, const int theType, const bool toTheEnd ) +void SMESHGUI_FilterTable::addRow (Table* theTable, const int theType, const bool toTheEnd) { int aCurrRow = 0; int aSelectedRow = getFirstSelectedRow(); int aCurrCol = theTable->currentColumn(); - if ( toTheEnd || aSelectedRow == -1 ) + myIsLocked = true; + if (toTheEnd || aSelectedRow == -1) { - theTable->insertRows( theTable->numRows() ); - aCurrRow = theTable->numRows() - 1; + theTable->insertRows(theTable->rowCount()); + aCurrRow = theTable->rowCount() - 1; } else { - theTable->insertRows( aSelectedRow ); + theTable->insertRows(aSelectedRow); aCurrRow = aSelectedRow; } + myIsLocked = false; + + // IPAL19372 - to prevent calling onCriterionChaged() slot before completion of setItem() + bool isSignalsBlocked = theTable->signalsBlocked(); + theTable->blockSignals( true ); // Criteria - theTable->setItem( aCurrRow, 0, getCriterionItem( theTable, theType ) ); + theTable->setItem(aCurrRow, 0, getCriterionItem(theType)); // Compare - theTable->setItem( aCurrRow, 1, getCompareItem( theTable ) ); + theTable->setItem(aCurrRow, 1, getCompareItem()); // Threshold - //theTable->setItem( aCurrRow, 2, new QTableItem( theTable ) ); + theTable->setItem(aCurrRow, 2, new QTableWidgetItem()); + + // Logical operation NOT + theTable->setItem(aCurrRow, 3, getUnaryItem()); + + // Logical operation AND / OR + theTable->setItem(aCurrRow, 4, new QTableWidgetItem()); + + theTable->setItem(aCurrRow, 5, new QTableWidgetItem()); + + theTable->blockSignals( isSignalsBlocked ); - //Logical operation NOT - theTable->setItem( aCurrRow, 3, getUnaryItem( theTable ) ); - // Logical binary operation for previous value int anAddBinOpStr = -1; - if ( aCurrRow == theTable->numRows() - 1 ) + if (aCurrRow == theTable->rowCount() - 1) anAddBinOpStr = aCurrRow - 1; - else if ( aCurrRow >= 0 ) + else if (aCurrRow >= 0 ) anAddBinOpStr = aCurrRow; - - if ( theTable->item( aCurrRow, 4 ) == 0 || - theTable->item( aCurrRow, 4 )->rtti() != 1 ) - { - - if ( anAddBinOpStr >= 0 && - ( theTable->item( anAddBinOpStr, 4 ) == 0 || - theTable->item( anAddBinOpStr, 4 )->rtti() != 1 ) ) - theTable->setItem( anAddBinOpStr, 4, getBinaryItem( theTable ) ); + if (theTable->item(aCurrRow, 4) == 0 || + theTable->item(aCurrRow, 4)->type() != ComboItem::Type()) + { + if (anAddBinOpStr >= 0 && + (theTable->item(anAddBinOpStr, 4) == 0 || + theTable->item(anAddBinOpStr, 4)->type() != ComboItem::Type())) + theTable->setItem(anAddBinOpStr, 4, getBinaryItem()); } - - theTable->SetEditable( false, theTable->numRows() - 1, 4 ); - if ( aCurrRow >=0 && aCurrRow < theTable->numRows() && - aCurrCol >=0 && aCurrCol < theTable->numRows() ) - theTable->setCurrentCell( aCurrRow, aCurrCol ); + theTable->setEditable(false, theTable->rowCount() - 1, 4); + + if (aCurrRow >=0 && aCurrRow < theTable->rowCount() && + aCurrCol >=0 && aCurrCol < theTable->rowCount()) + theTable->setCurrentCell(aCurrRow, aCurrCol); - onCriterionChanged( aCurrRow, 0 ); + onCriterionChanged(aCurrRow, 0); updateBtnState(); } @@ -1167,43 +2107,43 @@ void SMESHGUI_FilterTable::addRow( Table* theTable, const int theType, const boo // name : SMESHGUI_FilterTable::getCriterionItem // Purpose : Get combo table item for criteria of specified type //======================================================================= -QTableItem* SMESHGUI_FilterTable::getCriterionItem( QTable* theParent , const int theType ) +QTableWidgetItem* SMESHGUI_FilterTable::getCriterionItem (const int theType) const { - return new ComboItem( theParent, getCriteria( theType ) ); + return new ComboItem(getCriteria(theType)); } //======================================================================= // name : SMESHGUI_FilterTable::getCompareItem // Purpose : Get combo table item for operation of comparision //======================================================================= -QTableItem* SMESHGUI_FilterTable::getCompareItem( QTable* theParent ) +QTableWidgetItem* SMESHGUI_FilterTable::getCompareItem () const { - return new ComboItem( theParent, getCompare() ); + return new ComboItem(getCompare()); } //======================================================================= // name : SMESHGUI_FilterTable::getBinaryItem // Purpose : //======================================================================= -QTableItem* SMESHGUI_FilterTable::getBinaryItem( QTable* theParent ) +QTableWidgetItem* SMESHGUI_FilterTable::getBinaryItem () const { static QMap aMap; - if ( aMap.isEmpty() ) + if (aMap.isEmpty()) { - aMap[ SMESH::FT_LogicalAND ] = tr( "AND" ); - aMap[ SMESH::FT_LogicalOR ] = tr( "OR" ); + aMap[ SMESH::FT_LogicalAND ] = tr("AND"); + aMap[ SMESH::FT_LogicalOR ] = tr("OR"); } - return new ComboItem( theParent, aMap ); + return new ComboItem(aMap); } //======================================================================= // name : SMESHGUI_FilterTable::getUnaryItem // Purpose : Get check table item //======================================================================= -QTableItem* SMESHGUI_FilterTable::getUnaryItem( QTable* theParent ) +QTableWidgetItem* SMESHGUI_FilterTable::getUnaryItem () const { - return new QCheckTableItem( theParent, tr( "NOT" ) ); + return new CheckItem(tr("NOT")); } //======================================================================= @@ -1213,12 +2153,15 @@ QTableItem* SMESHGUI_FilterTable::getUnaryItem( QTable* theParent ) const QMap& SMESHGUI_FilterTable::getSupportedTypes() const { static QMap aTypes; - if ( aTypes.isEmpty() ) + if (aTypes.isEmpty()) { - aTypes[ SMESH::NODE ] = tr( "NODES" ); - aTypes[ SMESH::EDGE ] = tr( "EDGES" ); - aTypes[ SMESH::FACE ] = tr( "FACES" ); - aTypes[ SMESH::VOLUME ] = tr( "VOLUMES" ); + aTypes[ SMESH::NODE ] = tr("NODES"); + aTypes[ SMESH::ELEM0D ] = tr("ELEM0D"); + aTypes[ SMESH::BALL ] = tr("BALLS"); + aTypes[ SMESH::EDGE ] = tr("EDGES"); + aTypes[ SMESH::FACE ] = tr("FACES"); + aTypes[ SMESH::VOLUME ] = tr("VOLUMES"); + aTypes[ SMESH::ALL ] = tr("ELEMENTS"); } return aTypes; @@ -1228,67 +2171,174 @@ const QMap& SMESHGUI_FilterTable::getSupportedTypes() const // name : SMESHGUI_FilterTable::getCriteria // Purpose : Get criteria for specified type //======================================================================= -const QMap& SMESHGUI_FilterTable::getCriteria( const int theType ) const +const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) const { - if ( theType == SMESH::NODE ) + if (theType == SMESH::NODE) { static QMap aCriteria; - if ( aCriteria.isEmpty() ) + if (aCriteria.isEmpty()) { - aCriteria[ SMESH::FT_RangeOfIds ] = tr( "RANGE_OF_IDS" ); - aCriteria[ SMESH::FT_BelongToGeom ] = tr( "BELONG_TO_GEOM" ); - aCriteria[ SMESH::FT_BelongToPlane ] = tr( "BELONG_TO_PLANE" ); - aCriteria[ SMESH::FT_BelongToCylinder ] = tr( "BELONG_TO_CYLINDER" ); + aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); + aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP"); + aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM"); + aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE"); + aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER"); + aCriteria[ SMESH::FT_BelongToGenSurface ] = tr("BELONG_TO_GENSURFACE"); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM"); + aCriteria[ SMESH::FT_FreeNodes ] = tr("FREE_NODES"); + aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); + aCriteria[ SMESH::FT_EqualNodes ] = tr("EQUAL_NODE"); + aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS"); } return aCriteria; } - else if ( theType == SMESH::EDGE ) + else if (theType == SMESH::EDGE) { static QMap aCriteria; - if ( aCriteria.isEmpty() ) + if (aCriteria.isEmpty()) { - aCriteria[ SMESH::FT_FreeBorders ] = tr( "FREE_BORDERS" ); - aCriteria[ SMESH::FT_MultiConnection ] = tr( "MULTI_BORDERS" ); - aCriteria[ SMESH::FT_Length ] = tr( "LENGTH" ); - aCriteria[ SMESH::FT_RangeOfIds ] = tr( "RANGE_OF_IDS" ); - aCriteria[ SMESH::FT_BelongToGeom ] = tr( "BELONG_TO_GEOM" ); - aCriteria[ SMESH::FT_BelongToPlane ] = tr( "BELONG_TO_PLANE" ); - aCriteria[ SMESH::FT_BelongToCylinder ] = tr( "BELONG_TO_CYLINDER" ); + aCriteria[ SMESH::FT_FreeBorders ] = tr("FREE_BORDERS"); + aCriteria[ SMESH::FT_MultiConnection ] = tr("MULTI_BORDERS"); + aCriteria[ SMESH::FT_Length ] = tr("LENGTH"); + aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); + aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP"); + aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM"); + aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE"); + aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER"); + aCriteria[ SMESH::FT_BelongToGenSurface ] = tr("BELONG_TO_GENSURFACE"); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM"); + aCriteria[ SMESH::FT_LinearOrQuadratic ] = tr("LINEAR"); + aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); + aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE"); + aCriteria[ SMESH::FT_EqualEdges ] = tr("EQUAL_EDGE"); + aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE"); + aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS"); } return aCriteria; } - else if ( theType == SMESH::FACE ) + else if (theType == SMESH::FACE) { static QMap aCriteria; - if ( aCriteria.isEmpty() ) + if (aCriteria.isEmpty()) { - aCriteria[ SMESH::FT_AspectRatio ] = tr( "ASPECT_RATIO" ); - aCriteria[ SMESH::FT_Warping ] = tr( "WARPING" ); - aCriteria[ SMESH::FT_MinimumAngle ] = tr( "MINIMUM_ANGLE" ); - aCriteria[ SMESH::FT_Taper ] = tr( "TAPER" ); - aCriteria[ SMESH::FT_Skew ] = tr( "SKEW" ); - aCriteria[ SMESH::FT_Area ] = tr( "AREA" ); - aCriteria[ SMESH::FT_FreeEdges ] = tr( "FREE_EDGES" ); - aCriteria[ SMESH::FT_RangeOfIds ] = tr( "RANGE_OF_IDS" ); - aCriteria[ SMESH::FT_BelongToGeom ] = tr( "BELONG_TO_GEOM" ); - aCriteria[ SMESH::FT_BelongToPlane ] = tr( "BELONG_TO_PLANE" ); - aCriteria[ SMESH::FT_BelongToCylinder ] = tr( "BELONG_TO_CYLINDER" ); + aCriteria[ SMESH::FT_AspectRatio ] = tr("ASPECT_RATIO"); + aCriteria[ SMESH::FT_Warping ] = tr("WARPING"); + aCriteria[ SMESH::FT_MinimumAngle ] = tr("MINIMUM_ANGLE"); + aCriteria[ SMESH::FT_Taper ] = tr("TAPER"); + aCriteria[ SMESH::FT_Skew ] = tr("SKEW"); + aCriteria[ SMESH::FT_Area ] = tr("AREA"); + aCriteria[ SMESH::FT_MaxElementLength2D ] = tr("MAX_ELEMENT_LENGTH_2D"); + aCriteria[ SMESH::FT_FreeEdges ] = tr("FREE_EDGES"); + aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); + aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP"); + aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM"); + aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE"); + aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER"); + aCriteria[ SMESH::FT_BelongToGenSurface ] = tr("BELONG_TO_GENSURFACE"); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM"); + aCriteria[ SMESH::FT_Length2D ] = tr("LENGTH2D"); + aCriteria[ SMESH::FT_MultiConnection2D ] = tr("MULTI2D_BORDERS"); + aCriteria[ SMESH::FT_FreeFaces ] = tr("FREE_FACES"); + aCriteria[ SMESH::FT_BareBorderFace ] = tr("BARE_BORDER_FACE"); + aCriteria[ SMESH::FT_OverConstrainedFace] = tr("OVER_CONSTRAINED_FACE"); + aCriteria[ SMESH::FT_LinearOrQuadratic ] = tr("LINEAR"); + aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); + aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE"); + aCriteria[ SMESH::FT_CoplanarFaces ] = tr("COPLANAR_FACES"); + aCriteria[ SMESH::FT_EqualFaces ] = tr("EQUAL_FACE"); + aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE"); + aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS"); } return aCriteria; } - else if ( theType == SMESH::VOLUME ) + else if (theType == SMESH::VOLUME) { static QMap aCriteria; - if ( aCriteria.isEmpty() ) + if (aCriteria.isEmpty()) { - aCriteria[ SMESH::FT_RangeOfIds ] = tr( "RANGE_OF_IDS" ); - aCriteria[ SMESH::FT_BelongToGeom ] = tr( "BELONG_TO_GEOM" ); + aCriteria[ SMESH::FT_AspectRatio3D ] = tr("ASPECT_RATIO_3D"); + aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); + aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP"); + aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM"); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM"); + aCriteria[ SMESH::FT_BadOrientedVolume ] = tr("BAD_ORIENTED_VOLUME"); + aCriteria[ SMESH::FT_BareBorderVolume ] = tr("BARE_BORDER_VOLUME"); + aCriteria[ SMESH::FT_OverConstrainedVolume] = tr("OVER_CONSTRAINED_VOLUME"); + aCriteria[ SMESH::FT_Volume3D ] = tr("VOLUME_3D"); + aCriteria[ SMESH::FT_MaxElementLength3D ] = tr("MAX_ELEMENT_LENGTH_3D"); + aCriteria[ SMESH::FT_LinearOrQuadratic ] = tr("LINEAR"); + aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); + aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE"); + aCriteria[ SMESH::FT_EqualVolumes ] = tr("EQUAL_VOLUME"); + aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE"); + aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS"); } return aCriteria; } - else + else if (theType == SMESH::ELEM0D) + { + static QMap aCriteria; + if (aCriteria.isEmpty()) + { + aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); + aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP"); + aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM"); + aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE"); + aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER"); + aCriteria[ SMESH::FT_BelongToGenSurface ] = tr("BELONG_TO_GENSURFACE"); + aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); + aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS"); + } + return aCriteria; + } + else if (theType == SMESH::BALL) + { + static QMap aCriteria; + if (aCriteria.isEmpty()) + { + aCriteria[ SMESH::FT_BallDiameter ] = tr("BALL_DIAMETER"); + aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); + aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP"); + aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM"); + aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE"); + aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER"); + aCriteria[ SMESH::FT_BelongToGenSurface ] = tr("BELONG_TO_GENSURFACE"); + aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); + aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS"); + } + return aCriteria; + } + else if (theType == SMESH::ELEM0D) + { + static QMap aCriteria; + if (aCriteria.isEmpty()) + { + aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); + aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP"); + aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM"); + aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE"); + aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER"); + aCriteria[ SMESH::FT_BelongToGenSurface ] = tr("BELONG_TO_GENSURFACE"); + aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); + aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS"); + } + return aCriteria; + } + else // SMESH::ALL { static QMap aCriteria; + if (aCriteria.isEmpty()) + { + aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); + aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP"); + aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM"); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM"); + aCriteria[ SMESH::FT_LinearOrQuadratic ] = tr("LINEAR"); + aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); + aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE"); + aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS"); + } + return aCriteria; } } @@ -1302,11 +2352,11 @@ const QMap& SMESHGUI_FilterTable::getCompare() const { static QMap aMap; - if ( aMap.isEmpty() ) + if (aMap.isEmpty()) { - aMap[ SMESH::FT_LessThan ] = tr( "LESS_THAN" ); - aMap[ SMESH::FT_MoreThan ] = tr( "MORE_THAN" ); - aMap[ SMESH::FT_EqualTo ] = tr( "EQUAL_TO" ); + aMap[ SMESH::FT_LessThan ] = tr("LESS_THAN"); + aMap[ SMESH::FT_MoreThan ] = tr("MORE_THAN"); + aMap[ SMESH::FT_EqualTo ] = tr("EQUAL_TO" ); } return aMap; @@ -1316,61 +2366,64 @@ const QMap& SMESHGUI_FilterTable::getCompare() const // name : SMESHGUI_FilterTable::createTable // Purpose : Create table //======================================================================= -SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable( QWidget* theParent, - const int theType ) +SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* theParent, + const int theType) { // create table - Table* aTable= new Table( 0, 5, theParent ); + Table* aTable= new Table(0, 6, theParent); - QHeader* aHeaders = aTable->horizontalHeader(); + QHeaderView* aHeaders = aTable->horizontalHeader(); - QFontMetrics aMetrics( aHeaders->font() ); + QFontMetrics aMetrics(aHeaders->font()); // append spaces to the header of criteria in order to // provide visibility of criterion inside comboboxes static int aMaxLenCr = 0; - if ( aMaxLenCr == 0 ) + if (aMaxLenCr == 0) { const QMap& aSupportedTypes = getSupportedTypes(); QMap::const_iterator anIter; - for ( anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter ) - aMaxLenCr = Max( maxLength( getCriteria( anIter.key() ), aMetrics ), aMaxLenCr ); + for (anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter) + aMaxLenCr = qMax(maxLength(getCriteria(anIter.key()), aMetrics), aMaxLenCr); } - static int aLenCr = abs( aMaxLenCr - - aMetrics.width( tr( "CRITERION" ) ) ) / aMetrics.width( ' ' ) + 5; - - static int aLenCo = abs( maxLength( getCompare(), aMetrics ) - - aMetrics.width( tr( "COMPARE" ) ) ) / aMetrics.width( ' ' ) + 5; + static int aLenCr = qAbs( aMaxLenCr - + aMetrics.width(tr("CRITERION"))) / aMetrics.width(' ') + 5; QString aCrStr; - aCrStr.fill( ' ', aLenCr ); + aCrStr.fill(' ', aLenCr); QString aCoStr; - aCoStr.fill( ' ', 10 ); - - aHeaders->setLabel( 0, tr( "CRITERION" ) + aCrStr ); - aHeaders->setLabel( 1, tr( "COMPARE" ) + aCoStr ); - aHeaders->setLabel( 2, tr( "THRESHOLD_VALUE" ) ); - aHeaders->setLabel( 3, tr( "UNARY" ) ); - aHeaders->setLabel( 4, tr( "BINARY" ) + " " ); - + aCoStr.fill(' ', 10); + + QStringList aHeaderLabels; + aHeaderLabels.append( tr("CRITERION") + aCrStr ); + aHeaderLabels.append( tr("COMPARE") + aCoStr ); + aHeaderLabels.append( tr("THRESHOLD_VALUE") ); + aHeaderLabels.append( tr("UNARY") ); + aHeaderLabels.append( tr("BINARY") + " " ); + aHeaderLabels.append( tr("ID") ); + aTable->setHorizontalHeaderLabels( aHeaderLabels ); + // set geometry of the table - for ( int i = 0; i <= 4; i++ ) - aTable->adjustColumn( i ); + for (int i = 0; i <= 4; i++) + aTable->resizeColumnToContents(i); + + // set the ID column invisible + aTable->hideColumn( 5 ); aTable->updateGeometry(); QSize aSize = aTable->sizeHint(); int aWidth = aSize.width(); - aTable->setMinimumSize( QSize( aWidth, aWidth / 2 ) ); - aTable->setSizePolicy( QSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding) ); - - connect( aTable, SIGNAL( valueChanged( int, int ) ), - this, SLOT( onCriterionChanged( int, int ) ) ); + aTable->setMinimumSize(QSize(aWidth, aWidth / 2)); + aTable->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding)); - connect( aTable, SIGNAL( currentChanged( int, int ) ), - this, SLOT( onCurrentChanged( int, int ) ) ); + connect(aTable, SIGNAL(cellChanged(int, int)), + this, SLOT(onCriterionChanged(int, int))); + connect(aTable, SIGNAL(currentCellChanged(int, int, int, int)), + this, SLOT(onCurrentChanged(int, int))); + return aTable; } @@ -1380,22 +2433,37 @@ SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable( QWidget* thePar //======================================================================= void SMESHGUI_FilterTable::updateBtnState() { - myRemoveBtn->setEnabled( myTables[ GetType() ]->numRows() > 0 ); - myClearBtn->setEnabled( myTables[ GetType() ]->numRows() > 0 ); + myRemoveBtn->setEnabled(myTables[ GetType() ]->rowCount() > 0); + myClearBtn->setEnabled(myTables[ GetType() ]->rowCount() > 0); } //======================================================================= // name : SMESHGUI_FilterTable::SetEditable // Purpose : Set read only flag for tables. Show/hide buttons for work with rows //======================================================================= -void SMESHGUI_FilterTable::SetEditable( const bool isEditable ) +void SMESHGUI_FilterTable::SetEditable (const bool isEditable) { TableMap::iterator anIter; - for ( anIter = myTables.begin(); anIter != myTables.end(); ++anIter ) + for (anIter = myTables.begin(); anIter != myTables.end(); ++anIter) { - anIter.data()->setReadOnly( !isEditable ); + anIter.value()->setReadOnly(!isEditable); + + // Set Flags for CheckItems directly IPAL 19974 + Table* aTable = anIter.value(); + for (int i = 0, n = aTable->rowCount(); i < n; i++) + for (int j = 0, m = aTable->columnCount(); j < m; j++) + { + QTableWidgetItem* anItem = aTable->item(i, j); + if ( dynamic_cast( anItem ) ) { + Qt::ItemFlags f = anItem->flags(); + if (!isEditable) f = f & ~Qt::ItemIsUserCheckable; + else f = f | Qt::ItemIsUserCheckable; + anItem->setFlags( f ); + } + } + //end of IPAL19974 - if ( isEditable ) + if (isEditable) { myAddBtn->show(); myInsertBtn->show(); @@ -1411,28 +2479,28 @@ void SMESHGUI_FilterTable::SetEditable( const bool isEditable ) } } - QMap::iterator anIter2; - for ( anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2 ) - anIter2.data()->SetEditable( isEditable ); + QMap::iterator anIter2; + for (anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2) + anIter2.value()->SetEditable(isEditable); } //======================================================================= // name : SMESHGUI_FilterTable::SetEnabled // Purpose : Enable/Disable table. Switching type of elements already enabled //======================================================================= -void SMESHGUI_FilterTable::SetEnabled( const bool isEnabled ) +void SMESHGUI_FilterTable::SetEnabled (const bool isEnabled) { - myAddBtn->setEnabled( isEnabled ); - myInsertBtn->setEnabled( isEnabled ); - myRemoveBtn->setEnabled( isEnabled ); - myClearBtn->setEnabled( isEnabled ); + myAddBtn->setEnabled(isEnabled); + myInsertBtn->setEnabled(isEnabled); + myRemoveBtn->setEnabled(isEnabled); + myClearBtn->setEnabled(isEnabled); - if ( isEnabled ) + if (isEnabled) updateBtnState(); - - QMap::iterator anIter2; - for ( anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2 ) - anIter2.data()->setEnabled( isEnabled ); + + QMap::iterator anIter2; + for (anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2) + anIter2.value()->setEnabled(isEnabled); } //======================================================================= @@ -1448,9 +2516,9 @@ bool SMESHGUI_FilterTable::IsEditable() const // name : SMESHGUI_FilterTable::SetLibsEnabled // Purpose : Show/hide buttons for work with libraries //======================================================================= -void SMESHGUI_FilterTable::SetLibsEnabled( const bool isEnabled ) +void SMESHGUI_FilterTable::SetLibsEnabled (const bool isEnabled) { - if ( isEnabled ) + if (isEnabled) { myCopyFromBtn->show(); myAddToBtn->show(); @@ -1469,15 +2537,15 @@ void SMESHGUI_FilterTable::SetLibsEnabled( const bool isEnabled ) //======================================================================= void SMESHGUI_FilterTable::onCopyFromBtn() { - if ( myLibDlg == 0 ) + if (myLibDlg == 0) myLibDlg = new SMESHGUI_FilterLibraryDlg( - this, GetType(), SMESHGUI_FilterLibraryDlg::COPY_FROM ); + mySMESHGUI, this, GetType(), SMESHGUI_FilterLibraryDlg::COPY_FROM); else - myLibDlg->Init( GetType(), SMESHGUI_FilterLibraryDlg::COPY_FROM ); + myLibDlg->Init(GetType(), SMESHGUI_FilterLibraryDlg::COPY_FROM); - if ( myLibDlg->exec() == QDialog::Accepted ) + if (myLibDlg->exec() == QDialog::Accepted) { - Copy( myLibDlg->GetTable() ); + Copy(myLibDlg->GetTable()); Update(); } } @@ -1489,32 +2557,32 @@ void SMESHGUI_FilterTable::onCopyFromBtn() //======================================================================= void SMESHGUI_FilterTable::onAddToBtn() { - if ( !IsValid( true ) ) + if (!IsValid(true)) return; - if ( myLibDlg == 0 ) + if (myLibDlg == 0) myLibDlg = new SMESHGUI_FilterLibraryDlg( - this, GetType(), SMESHGUI_FilterLibraryDlg::ADD_TO ); + mySMESHGUI, this, GetType(), SMESHGUI_FilterLibraryDlg::ADD_TO); else - myLibDlg->Init( GetType(), SMESHGUI_FilterLibraryDlg::ADD_TO ); + myLibDlg->Init(GetType(), SMESHGUI_FilterLibraryDlg::ADD_TO); + + myLibDlg->SetTable(this); - myLibDlg->SetTable( this ); - myLibDlg->exec(); -} +} //======================================================================= // name : SMESHGUI_FilterTable::Copy // Purpose : Initialise table with values of other table //======================================================================= -void SMESHGUI_FilterTable::Copy( const SMESHGUI_FilterTable* theTable ) +void SMESHGUI_FilterTable::Copy (const SMESHGUI_FilterTable* theTable) { Clear(); - for ( int i = 0, n = theTable->NumRows(); i < n; i++ ) + for (int i = 0, n = theTable->NumRows(); i < n; i++) { SMESH::Filter::Criterion aCriterion = SMESHGUI_FilterDlg::createCriterion(); - theTable->GetCriterion( i, aCriterion ); - AddCriterion( aCriterion ); + theTable->GetCriterion(i, aCriterion); + AddCriterion(aCriterion); } } @@ -1522,7 +2590,7 @@ void SMESHGUI_FilterTable::Copy( const SMESHGUI_FilterTable* theTable ) // name : SMESHGUI_FilterTable::CurrentCell // Purpose : Returns current cell //======================================================================= -bool SMESHGUI_FilterTable::CurrentCell( int& theRow, int& theCol ) const +bool SMESHGUI_FilterTable::CurrentCell (int& theRow, int& theCol) const { theRow = myTables[ GetType() ]->currentRow(); theCol = myTables[ GetType() ]->currentColumn(); @@ -1531,36 +2599,73 @@ bool SMESHGUI_FilterTable::CurrentCell( int& theRow, int& theCol ) const //======================================================================= // name : SMESHGUI_FilterTable::SetText -// Purpose : Set text and internal value in cell of threshold value +// Purpose : Set text and internal value in cell of threshold value //======================================================================= -void SMESHGUI_FilterTable::SetThreshold( const int theRow, +void SMESHGUI_FilterTable::SetThreshold (const int theRow, const QString& theText, - const int theEntityType ) + const int theEntityType) { Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ]; - aTable->setText( theRow, 2, theText ); + + bool isSignalsBlocked = aTable->signalsBlocked(); + aTable->blockSignals(true); + + aTable->item( theRow, 2 )->setText(theText); + + aTable->blockSignals(isSignalsBlocked); } //======================================================================= // name : SMESHGUI_FilterTable::SetText // Purpose : Get text and internal value from cell of threshold value //======================================================================= -bool SMESHGUI_FilterTable::GetThreshold( const int theRow, +bool SMESHGUI_FilterTable::GetThreshold (const int theRow, QString& theText, - const int theEntityType ) + const int theEntityType) { Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ]; - QTableItem* anItem = aTable->item( theRow, 2 ); - if ( anItem != 0 ) + QTableWidgetItem* anItem = aTable->item(theRow, 2); + if (anItem != 0) { theText = anItem->text(); - return true; + return true; } else return false; } -/* +//======================================================================= +// name : SMESHGUI_FilterTable::SetID +// Purpose : Set text and internal value in cell of ID value +//======================================================================= +void SMESHGUI_FilterTable::SetID( const int theRow, + const QString& theText, + const int theEntityType ) +{ + Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ]; + aTable->item( theRow, 5 )->setText( theText ); +} + +//======================================================================= +// name : SMESHGUI_FilterTable::GetID +// Purpose : Get text and internal value from cell of ID value +//======================================================================= +bool SMESHGUI_FilterTable::GetID( const int theRow, + QString& theText, + const int theEntityType ) +{ + Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ]; + QTableWidgetItem* anItem = aTable->item( theRow, 5 ); + if ( anItem != 0 ) + { + theText = anItem->text(); + return true; + } + else + return false; +} + +/* Class : SMESHGUI_FilterDlg Description : Dialog to specify filters for VTK viewer */ @@ -1570,83 +2675,112 @@ bool SMESHGUI_FilterTable::GetThreshold( const int theRow, // name : SMESHGUI_FilterDlg::SMESHGUI_FilterDlg // Purpose : Constructor //======================================================================= -SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( QWidget* theParent, - const QValueList& theTypes, - const char* theName ) -: QDialog( theParent, theName, false, - WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu ) +SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule, + const QList& theTypes ) +: QDialog( SMESH::GetDesktop( theModule ) ), + mySMESHGUI( theModule ), + mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ), + myInitSourceWgOnApply( true ), + myInsertEnabled( true ), + myDiffSourcesEnabled( true ) { - construct( theTypes ); + if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) + mySelector = aViewWindow->GetSelector(); + + construct(theTypes); } //======================================================================= // name : SMESHGUI_FilterDlg::SMESHGUI_FilterDlg // Purpose : Constructor //======================================================================= -SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( QWidget* theParent, - const int theType, - const char* theName ) -: QDialog( theParent, theName, false, - WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu ) +SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule, + const int theType ) +: QDialog( SMESH::GetDesktop( theModule ) ), + mySMESHGUI( theModule ), + mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ), + myInitSourceWgOnApply( true ), + myInsertEnabled( true ), + myDiffSourcesEnabled( true ) { - QValueList aTypes; - aTypes.append( theType ); - construct( aTypes ); + if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) + mySelector = aViewWindow->GetSelector(); + QList aTypes; + aTypes.append(theType); + construct(aTypes); } //======================================================================= // name : SMESHGUI_FilterDlg::construct -// Purpose : Construct dialog ( called by constructor ) +// Purpose : Construct dialog (called by constructor) //======================================================================= -void SMESHGUI_FilterDlg::construct( const QValueList& theTypes ) +void SMESHGUI_FilterDlg::construct (const QList& theTypes) { myTypes = theTypes; - setCaption( tr( "CAPTION" ) ); + setModal(false); + //setAttribute(Qt::WA_DeleteOnClose, true); // VSR ??? is it required? + setWindowTitle(tr("CAPTION")); + + QVBoxLayout* aDlgLay = new QVBoxLayout (this); + aDlgLay->setMargin(MARGIN); + aDlgLay->setSpacing(SPACING); - QVBoxLayout* aDlgLay = new QVBoxLayout( this, MARGIN, SPACING ); + myMainFrame = createMainFrame (this); + QWidget* aBtnFrame = createButtonFrame(this); - myMainFrame = createMainFrame ( this ); - QFrame* aBtnFrame = createButtonFrame( this ); + aDlgLay->addWidget(myMainFrame); + aDlgLay->addWidget(aBtnFrame); - aDlgLay->addWidget( myMainFrame ); - aDlgLay->addWidget( aBtnFrame ); + aDlgLay->setStretchFactor(myMainFrame, 1); - aDlgLay->setStretchFactor( myMainFrame, 1 ); + myHelpFileName = "selection_filter_library_page.html"; - Init( myTypes ); + Init(myTypes); } //======================================================================= // name : SMESHGUI_FilterDlg::createMainFrame // Purpose : Create frame containing dialog's input fields //======================================================================= -QFrame* SMESHGUI_FilterDlg::createMainFrame( QWidget* theParent ) +QWidget* SMESHGUI_FilterDlg::createMainFrame (QWidget* theParent) { - QGroupBox* aMainFrame = new QGroupBox( 1, Qt::Horizontal, theParent ); - aMainFrame->setFrameStyle( QFrame::NoFrame ); - aMainFrame->setInsideMargin( 0 ); + QWidget* aMainFrame = new QWidget(theParent); + QVBoxLayout* aMainLay = new QVBoxLayout(aMainFrame); + aMainLay->setMargin(0); + aMainLay->setSpacing(SPACING); // filter frame - myTable = new SMESHGUI_FilterTable( aMainFrame, myTypes ); - myTable->SetLibsEnabled( true ); + myTable = new SMESHGUI_FilterTable( mySMESHGUI, aMainFrame, myTypes ); + myTable->SetLibsEnabled(true); - QFrame* aLine = new QFrame( myTable->GetTableGrp() ); - aLine->setFrameStyle( QFrame::HLine | QFrame::Sunken ); + QGroupBox* aGrp = myTable->GetTableGrp(); + QGridLayout* aLay = qobject_cast( aGrp->layout() ); + int rows = aLay->rowCount(); + int cols = aLay->columnCount(); - mySetInViewer = new QCheckBox( tr( "SET_IN_VIEWER" ), myTable->GetTableGrp() ); - mySetInViewer->setChecked( true ); + // This line looks strange when all additional parameters and mySetInViewer are hidden + QFrame* aLine = new QFrame(aGrp); + aLine->setFrameStyle(QFrame::HLine | QFrame::Sunken); + aLay->addWidget(aLine, rows++, 0, 1, cols); + + mySetInViewer = new QCheckBox(tr("SET_IN_VIEWER"), aGrp); + mySetInViewer->setChecked(true); + aLay->addWidget(mySetInViewer, rows++, 0, 1, cols); // other controls - mySourceGrp = createSourceGroup( aMainFrame ); + QWidget* aSourceGrp = createSourceGroup(aMainFrame); - connect( myTable, SIGNAL( CretarionChanged( const int, const int ) ), - SLOT( onCriterionChanged( const int, const int ) ) ); + connect(myTable, SIGNAL(CriterionChanged(const int, const int)), + SLOT(onCriterionChanged(const int, const int))); - connect( myTable, SIGNAL( CurrentChanged( int, int ) ), - SLOT( onCurrentChanged( int, int ) ) ); + connect(myTable, SIGNAL(CurrentChanged(int, int)), + SLOT(onCurrentChanged(int, int))); + aMainLay->addWidget(myTable); + aMainLay->addWidget(aSourceGrp); + return aMainFrame; } @@ -1654,42 +2788,47 @@ QFrame* SMESHGUI_FilterDlg::createMainFrame( QWidget* theParent ) // name : SMESHGUI_FilterDlg::createSourceFrame // Purpose : Create frame containing source radio button //======================================================================= -QButtonGroup* SMESHGUI_FilterDlg::createSourceGroup( QWidget* theParent ) +QWidget* SMESHGUI_FilterDlg::createSourceGroup (QWidget* theParent) { - QButtonGroup* aGrp = new QButtonGroup( 1, Qt::Vertical, tr( "SOURCE" ), theParent ); + QGroupBox* aBox = new QGroupBox(tr("SOURCE"), theParent); + QHBoxLayout* aLay = new QHBoxLayout(aBox); + aLay->setMargin(MARGIN); + aLay->setSpacing(SPACING); - QRadioButton* aMeshBtn = new QRadioButton( tr( "MESH" ), aGrp ); - QRadioButton* aSelBtn = new QRadioButton( tr( "SELECTION" ), aGrp ); - QRadioButton* aGrpBtn = new QRadioButton( tr( "CURRENT_GROUP" ), aGrp ); + mySourceGrp = new QButtonGroup(theParent); - aGrp->insert( aMeshBtn, Mesh ); - aGrp->insert( aSelBtn, Selection ); - aGrp->insert( aGrpBtn, Dialog ); + QRadioButton* aMeshBtn = new QRadioButton(tr("MESH"), aBox); + QRadioButton* aSelBtn = new QRadioButton(tr("SELECTION"), aBox); + QRadioButton* aDlgBtn = new QRadioButton(tr("CURRENT_DIALOG"),aBox); - aGrp->setButton( Selection ); + aLay->addWidget(aMeshBtn); + aLay->addWidget(aSelBtn); + aLay->addWidget(aDlgBtn); - return aGrp; + mySourceGrp->addButton(aMeshBtn, Mesh); + mySourceGrp->addButton(aSelBtn, Selection); + mySourceGrp->addButton(aDlgBtn, Dialog); + + aMeshBtn->setChecked(true); + + return aBox; } //======================================================================= // name : SMESHGUI_FilterDlg::updateMainButtons -// Purpose : Update visibility of main buttons ( OK, Cancel, Close ... ) +// Purpose : Update visibility of main buttons (OK, Cancel, Close ...) //======================================================================= void SMESHGUI_FilterDlg::updateMainButtons() { - if ( myTypes.count() == 1 ) + myButtons[ BTN_Close ]->show(); + if (myTypes.count() == 1) { - myButtons[ BTN_Cancel ]->show(); myButtons[ BTN_Apply ]->hide(); - myButtons[ BTN_Close ]->hide(); } else { - myButtons[ BTN_Cancel ]->hide(); myButtons[ BTN_Apply ]->show(); - myButtons[ BTN_Close ]->show(); } - // updateGeometry(); } @@ -1697,23 +2836,30 @@ void SMESHGUI_FilterDlg::updateMainButtons() // name : SMESHGUI_FilterDlg::createButtonFrame // Purpose : Create frame containing buttons //======================================================================= -QFrame* SMESHGUI_FilterDlg::createButtonFrame( QWidget* theParent ) +QWidget* SMESHGUI_FilterDlg::createButtonFrame (QWidget* theParent) { - QGroupBox* aGrp = new QGroupBox( 1, Qt::Vertical, theParent ); + QGroupBox* aGrp = new QGroupBox(theParent); + QHBoxLayout* aLay = new QHBoxLayout(aGrp); + aLay->setMargin(MARGIN); + aLay->setSpacing(SPACING); - myButtons[ BTN_OK ] = new QPushButton( tr( "SMESH_BUT_OK" ), aGrp ); - myButtons[ BTN_Apply ] = new QPushButton( tr( "SMESH_BUT_APPLY" ), aGrp ); + myButtons[ BTN_OK ] = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), aGrp); + myButtons[ BTN_Apply ] = new QPushButton(tr("SMESH_BUT_APPLY"), aGrp); + myButtons[ BTN_Close ] = new QPushButton(tr("SMESH_BUT_CLOSE"), aGrp); + myButtons[ BTN_Help ] = new QPushButton(tr("SMESH_BUT_HELP"), aGrp); - QLabel* aLbl = new QLabel( aGrp ); - aLbl->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) ); + aLay->addWidget(myButtons[ BTN_OK ]); + aLay->addSpacing(10); + aLay->addWidget(myButtons[ BTN_Apply ]); + aLay->addSpacing(10); + aLay->addStretch(); + aLay->addWidget(myButtons[ BTN_Close ]); + aLay->addWidget(myButtons[ BTN_Help ]); - myButtons[ BTN_Cancel ] = new QPushButton( tr( "SMESH_BUT_CANCEL" ), aGrp ); - myButtons[ BTN_Close ] = new QPushButton( tr( "SMESH_BUT_CLOSE" ), aGrp ); - - connect( myButtons[ BTN_OK ], SIGNAL( clicked() ), SLOT( onOk() ) ); - connect( myButtons[ BTN_Cancel ], SIGNAL( clicked() ), SLOT( onClose() ) ) ; - connect( myButtons[ BTN_Close ], SIGNAL( clicked() ), SLOT( onClose() ) ) ; - connect( myButtons[ BTN_Apply ], SIGNAL( clicked() ), SLOT( onApply() ) ); + connect(myButtons[ BTN_OK ], SIGNAL(clicked()), SLOT(onOk())); + connect(myButtons[ BTN_Close ], SIGNAL(clicked()), SLOT(reject())); + connect(myButtons[ BTN_Apply ], SIGNAL(clicked()), SLOT(onApply())); + connect(myButtons[ BTN_Help ], SIGNAL(clicked()), SLOT(onHelp())); updateMainButtons(); @@ -1732,82 +2878,81 @@ SMESHGUI_FilterDlg::~SMESHGUI_FilterDlg() // name : SMESHGUI_FilterDlg::Init // Purpose : Init dialog fields, connect signals and slots, show dialog //======================================================================= -void SMESHGUI_FilterDlg::Init( const int type ) +void SMESHGUI_FilterDlg::Init (const int type, const bool setInViewer) { - QValueList aTypes; - aTypes.append( type ); - Init( aTypes ); + QList aTypes; + aTypes.append(type); + Init(aTypes,setInViewer); } //======================================================================= // name : SMESHGUI_FilterDlg::Init // Purpose : Init dialog fields, connect signals and slots, show dialog //======================================================================= -void SMESHGUI_FilterDlg::Init( const QValueList& theTypes ) +void SMESHGUI_FilterDlg::Init (const QList& theTypes, const bool setInViewer) { mySourceWg = 0; - mySelection = 0; myTypes = theTypes; myMesh = SMESH::SMESH_Mesh::_nil(); + myGroup = SMESH::SMESH_GroupOnFilter::_nil(); myIObjects.Clear(); myIsSelectionChanged = false; + myToRestoreSelMode = false; - myTable->Init( theTypes ); + myTable->Init(theTypes); // set caption - if ( theTypes.count() == 1 ) + if (theTypes.count() == 1) { int aType = theTypes.first(); - if ( aType == SMESH::NODE ) setCaption( tr( "NODES_TLT" ) ); - else if ( aType == SMESH::EDGE ) setCaption( tr( "EDGES_TLT" ) ); - else if ( aType == SMESH::FACE ) setCaption( tr( "FACES_TLT" ) ); - else if ( aType == SMESH::VOLUME ) setCaption( tr( "VOLUMES_TLT" ) ); + if (aType == SMESH::NODE ) setWindowTitle(tr("NODES_TLT")); + else if (aType == SMESH::ELEM0D) setWindowTitle(tr("ELEM0D_TLT")); + else if (aType == SMESH::BALL ) setWindowTitle(tr("BALL_TLT")); + else if (aType == SMESH::EDGE ) setWindowTitle(tr("EDGES_TLT")); + else if (aType == SMESH::FACE ) setWindowTitle(tr("FACES_TLT")); + else if (aType == SMESH::VOLUME) setWindowTitle(tr("VOLUMES_TLT")); + else if (aType == SMESH::ALL) setWindowTitle(tr("TLT")); } else - setCaption( tr( "TLT" ) ); + setWindowTitle(tr("TLT")); qApp->processEvents(); updateGeometry(); adjustSize(); - setEnabled( true ); - - mySMESHGUI = SMESHGUI::GetSMESHGUI() ; - mySMESHGUI->SetActiveDialogBox( ( QDialog* )this ) ; + setEnabled(true); - connect( mySMESHGUI, SIGNAL( SignalDeactivateActiveDialog() ), SLOT( onDeactivate() ) ); - connect( mySMESHGUI, SIGNAL( SignalCloseAllDialogs() ), SLOT( onClose() ) ); - - int x, y ; - mySMESHGUI->DefineDlgPosition( this, x, y ); - this->move( x, y ); + mySMESHGUI->SetActiveDialogBox((QDialog*)this); + connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(onDeactivate())); + connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject())); + updateMainButtons(); updateSelection(); // Initialise filter table with values of previous filter - QValueList::const_iterator anIter; - for ( anIter = theTypes.begin(); anIter != theTypes.end(); ++anIter ) + QList::const_iterator anIter; + for (anIter = theTypes.begin(); anIter != theTypes.end(); ++anIter) { - myTable->Clear( *anIter ); - if ( !myFilter[ *anIter ]->_is_nil() ) + myTable->Clear(*anIter); + if (!myFilter[ *anIter ]->_is_nil()) { SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria; - if ( myFilter[ *anIter ]->GetCriteria( aCriteria ) ) + if (myFilter[ *anIter ]->GetCriteria(aCriteria)) { - for ( int i = 0, n = aCriteria->length(); i < n; i++ ) - myTable->AddCriterion( aCriteria[ i ], *anIter ); + for (int i = 0, n = aCriteria->length(); i < n; i++) + myTable->AddCriterion(aCriteria[ i ], *anIter); } } } - if ( myInsertState.contains( theTypes.first() ) ) - mySetInViewer->setChecked( myInsertState[ theTypes.first() ] ); + if (myInsertState.contains(theTypes.first())) + mySetInViewer->setChecked(myInsertState[ theTypes.first() ]); else - mySetInViewer->setChecked( true ); - if ( myApplyToState.contains( theTypes.first() ) ) - mySourceGrp->setButton( myApplyToState[ theTypes.first() ] ); - else - mySourceGrp->setButton( Selection ); + mySetInViewer->setChecked(setInViewer); + + mySourceGrp->button(myApplyToState.contains(theTypes.first()) ? + myApplyToState[ theTypes.first() ] : + Mesh)->setChecked(true); } //======================================================================= @@ -1817,47 +2962,76 @@ void SMESHGUI_FilterDlg::Init( const QValueList& theTypes ) //======================================================================= void SMESHGUI_FilterDlg::onOk() { - if ( onApply() ) + if (onApply()) { - mySelection->ClearFilters(); - disconnect( mySMESHGUI, 0, this, 0 ); - disconnect( mySelection, 0, this, 0 ); - mySMESHGUI->ResetState() ; + restoreSelMode(); + mySelectionMgr->clearFilters(); + disconnect(mySMESHGUI, 0, this, 0); + disconnect(mySelectionMgr, 0, this, 0); + mySMESHGUI->ResetState(); accept(); emit Accepted(); } } //======================================================================= -// name : SMESHGUI_FilterDlg::onClose +// name : SMESHGUI_FilterDlg::reject // Purpose : SLOT called when "Close" button pressed. Close dialog //======================================================================= -void SMESHGUI_FilterDlg::onClose() +void SMESHGUI_FilterDlg::reject() { + restoreSelMode(); // Restore previously selected object - if ( mySelection ) + if (mySelectionMgr) { - mySelection->ClearFilters(); - mySelection->Clear(); - SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter( myIObjects ); - for ( ; anIter.More(); anIter.Next() ) + SALOME_ListIO aList; + mySelectionMgr->clearFilters(); + mySelectionMgr->clearSelected(); + SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter (myIObjects); + for ( ; anIter.More(); anIter.Next()) { - mySelection->AddIObject( anIter.Key() ); + aList.Append(anIter.Key()); TColStd_MapOfInteger aResMap; const TColStd_IndexedMapOfInteger& anIndMap = anIter.Value(); - for ( int i = 1, n = anIndMap.Extent(); i <= n; i++ ) - aResMap.Add( anIndMap( i ) ); - - mySelection->AddOrRemoveIndex( anIter.Key(), aResMap, false ); + for (int i = 1, n = anIndMap.Extent(); i <= n; i++) + aResMap.Add(anIndMap(i)); + + mySelector->AddOrRemoveIndex( anIter.Key(), aResMap, false); + if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) + aViewWindow->highlight( anIter.Key(), true, true ); } + mySelectionMgr->setSelectedObjects(aList, false); } - disconnect( mySMESHGUI, 0, this, 0 ); - disconnect( mySelection, 0, this, 0 ); - mySMESHGUI->ResetState() ; - reject() ; - return ; + disconnect(mySMESHGUI, 0, this, 0); + disconnect(mySelectionMgr, 0, this, 0); + mySMESHGUI->ResetState(); + QDialog::reject(); +} + +//================================================================================= +// function : onHelp() +// purpose : +//================================================================================= +void SMESHGUI_FilterDlg::onHelp() +{ + LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication()); + if (app) + app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName); + else { + QString platform; +#ifdef WIN32 + platform = "winapplication"; +#else + platform = "application"; +#endif + SUIT_MessageBox::warning(this, tr("WRN_WARNING"), + tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE"). + arg(app->resourceMgr()->stringValue("ExternalBrowser", + platform)). + arg(myHelpFileName)); + } } //======================================================================= @@ -1866,65 +3040,57 @@ void SMESHGUI_FilterDlg::onClose() //======================================================================= void SMESHGUI_FilterDlg::onDeactivate() { - setEnabled( false ); + setEnabled(false); } //======================================================================= // name : SMESHGUI_FilterDlg::enterEvent // Purpose : Event filter //======================================================================= -void SMESHGUI_FilterDlg::enterEvent( QEvent* ) +void SMESHGUI_FilterDlg::enterEvent (QEvent*) { // mySMESHGUI->EmitSignalDeactivateDialog(); - setEnabled( true ); -} - - -//================================================================================= -// function : closeEvent() -// purpose : -//================================================================================= -void SMESHGUI_FilterDlg::closeEvent( QCloseEvent* e ) -{ - onClose() ; + mySMESHGUI->SetActiveDialogBox((QDialog*)this); + mySMESHGUI->ResetState(); + setEnabled(true); } //======================================================================= // name : SMESHGUI_FilterDlg::getIdsFromWg // Purpose : Retrieve list of ids from given widget //======================================================================= -void SMESHGUI_FilterDlg::getIdsFromWg( const QWidget* theWg, QValueList& theRes ) const +void SMESHGUI_FilterDlg::getIdsFromWg (const QWidget* theWg, QList& theRes) const { theRes.clear(); - if ( theWg == 0 ) + if (theWg == 0) return; - if ( theWg->inherits( "QListBox" ) ) + if (theWg->inherits("QListWidget")) { - QListBox* aListBox = ( QListBox* )theWg; + const QListWidget* aListBox = qobject_cast( theWg ); bool b; - for ( int i = 0, n = aListBox->count(); i < n; i++ ) + for (int i = 0, n = aListBox->count(); i < n; i++) { - int anId = aListBox->text( i ).toInt( &b ); - if ( b ) - theRes.append( anId ); + int anId = aListBox->item(i)->text().toInt(&b); + if (b) + theRes.append(anId); } } - else if ( theWg->inherits( "QLineEdit" ) ) + else if (theWg->inherits("QLineEdit")) { - QLineEdit* aLineEdit = ( QLineEdit* )theWg; + const QLineEdit* aLineEdit = qobject_cast( theWg ); QString aStr = aLineEdit->text(); - QRegExp aRegExp( "(\\d+)" ); + QRegExp aRegExp("(\\d+)"); bool b; int aPos = 0; - while ( aPos >= 0 ) + while (aPos >= 0) { - aPos = aRegExp.search( aStr, aPos ); - if ( aPos > -1 ) + aPos = aRegExp.indexIn(aStr, aPos); + if (aPos > -1) { - int anId = aRegExp.cap( 1 ).toInt( &b ); - if ( b ) - theRes.append( anId ); + int anId = aRegExp.cap(1).toInt(&b); + if (b) + theRes.append(anId); aPos += aRegExp.matchedLength(); } } @@ -1935,14 +3101,17 @@ void SMESHGUI_FilterDlg::getIdsFromWg( const QWidget* theWg, QValueList& th // name : SMESHGUI_FilterDlg::getSelMode // Purpose : Get selection mode of specified type //======================================================================= -Selection_Mode SMESHGUI_FilterDlg::getSelMode( const int theType ) const +Selection_Mode SMESHGUI_FilterDlg::getSelMode (const int theType) const { - switch ( theType ) + switch (theType) { case SMESH::NODE : return NodeSelection; + case SMESH::ELEM0D : return Elem0DSelection; + case SMESH::BALL : return BallSelection; case SMESH::EDGE : return EdgeSelection; case SMESH::FACE : return FaceSelection; case SMESH::VOLUME : return VolumeSelection; + case SMESH::ALL : return CellSelection; default : return ActorSelection; } @@ -1952,36 +3121,23 @@ Selection_Mode SMESHGUI_FilterDlg::getSelMode( const int theType ) const // name : SMESHGUI_FilterDlg::setIdsToWg // Purpose : Insert identifiers in specified widgets //======================================================================= -void SMESHGUI_FilterDlg::setIdsToWg( QWidget* theWg, const QValueList& theIds ) +void SMESHGUI_FilterDlg::setIdsToWg (QWidget* theWg, const QList& theIds) { - if ( theWg == 0 ) + if (theWg == 0) return; - if ( theWg->inherits( "QListBox" ) ) - { - QListBox* aListBox = ( QListBox* )theWg; - aListBox->clear(); - - QStringList aStrList; - QValueList::const_iterator anIter; - for ( anIter = theIds.begin(); anIter != theIds.end(); ++anIter ) - aStrList.append( QString( "%1" ).arg( *anIter ) ); + QStringList aStrList; + foreach(int id, theIds) + aStrList << QString::number(id); - aListBox->insertStringList( aStrList ); + if (theWg->inherits("QListWidget")) + { + qobject_cast(theWg)->clear(); + qobject_cast(theWg)->addItems(aStrList); } - else if ( theWg->inherits( "QLineEdit" ) ) + else if (theWg->inherits("QLineEdit")) { - QLineEdit* aLineEdit = ( QLineEdit* )theWg; - QString aStr; - QValueList::const_iterator anIter; - - for ( anIter = theIds.begin(); anIter != theIds.end(); ++ anIter ) - aStr += QString( "%1 " ).arg( *anIter ); - - if ( !aStr.isEmpty() ) - aStr.remove( aStr.length() - 1, 1 ); - - aLineEdit->setText( aStr ); + qobject_cast( theWg )->setText(aStrList.join(" ")); } } @@ -1991,68 +3147,88 @@ void SMESHGUI_FilterDlg::setIdsToWg( QWidget* theWg, const QValueList& theI //======================================================================= bool SMESHGUI_FilterDlg::isValid() const { - if ( !myTable->IsValid() ) + if (!myTable->IsValid()) return false; - - for ( int i = 0, n = myTable->NumRows(); i < n; i++ ) + + for (int i = 0, n = myTable->NumRows(); i < n; i++) { - int aType = myTable->GetCriterionType( i ); - if ( aType == FT_BelongToGeom || - aType == FT_BelongToPlane || - aType == FT_BelongToCylinder ) + int aType = myTable->GetCriterionType(i); + if (aType == SMESH::FT_BelongToGeom || + aType == SMESH::FT_BelongToPlane || + aType == SMESH::FT_BelongToCylinder || + aType == SMESH::FT_BelongToGenSurface || + aType == SMESH::FT_LyingOnGeom) { QString aName; - myTable->GetThreshold( i, aName ); - - SALOMEDS::Study::ListOfSObject_var aList = SMESHGUI::GetSMESHGUI()->GetActiveStudy()-> - getStudyDocument()->FindObjectByName( aName.latin1(), "GEOM" ); - if ( aList->length() == 0 ) - { - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "BAD_SHAPE_NAME" ).arg( aName ), QMessageBox::Ok ); + myTable->GetThreshold(i, aName); + + std::vector<_PTR(SObject)> aList = + SMESH::GetActiveStudyDocument()->FindObjectByName(aName.toLatin1().constData(), "GEOM"); + if (aList.size() == 0) { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("BAD_SHAPE_NAME").arg(aName)); return false; } - if ( aType == FT_BelongToCylinder || aType == FT_BelongToPlane ) - { - GEOM::GEOM_Object_var aGeomObj = - GEOM::GEOM_Object::_narrow( aList[ 0 ]->GetObject() ); - if ( !aGeomObj->_is_nil() ) - { + if (aType == SMESH::FT_BelongToCylinder || + aType == SMESH::FT_BelongToPlane || + aType == SMESH::FT_BelongToGenSurface ) { + CORBA::Object_var anObject = SMESH::SObjectToObject(aList[ 0 ]); + GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(anObject); + if (!aGeomObj->_is_nil()) { TopoDS_Shape aFace; - if ( !GEOMBase::GetShape( aGeomObj, aFace ) || + if (!GEOMBase::GetShape(aGeomObj, aFace) || aFace.IsNull() || - aFace.ShapeType() != TopAbs_FACE ) - { - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "SHAPE_IS_NOT_A_FACE" ).arg( aName ), QMessageBox::Ok ); + aFace.ShapeType() != TopAbs_FACE) { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("SHAPE_IS_NOT_A_FACE").arg(aName)); return false; } - Handle(Geom_Surface) aSurf = BRep_Tool::Surface( TopoDS::Face( aFace ) ); - if ( aSurf.IsNull() ) - { - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "SHAPE_IS_NOT_A_FACE" ).arg( aName ), QMessageBox::Ok ); + Handle(Geom_Surface) aSurf = BRep_Tool::Surface(TopoDS::Face(aFace)); + if (aSurf.IsNull()) { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("SHAPE_IS_NOT_A_FACE").arg(aName)); return false; } - if ( aType == FT_BelongToPlane && !aSurf->IsKind( STANDARD_TYPE( Geom_Plane ) ) ) - { - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "SHAPE_IS_NOT_A_PLANE" ).arg( aName ), QMessageBox::Ok ); + if (aType == SMESH::FT_BelongToPlane && !aSurf->IsKind(STANDARD_TYPE(Geom_Plane))) { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("SHAPE_IS_NOT_A_PLANE").arg(aName)); return false; } - if ( aType == FT_BelongToCylinder && !aSurf->IsKind( STANDARD_TYPE( Geom_CylindricalSurface ) ) ) - { - QMessageBox::information( SMESHGUI::GetSMESHGUI()->GetDesktop(), - tr( "SMESH_INSUFFICIENT_DATA" ), tr( "SHAPE_IS_NOT_A_CYLINDER" ).arg( aName ), QMessageBox::Ok ); + if (aType == SMESH::FT_BelongToCylinder && !aSurf->IsKind(STANDARD_TYPE(Geom_CylindricalSurface))) { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("SHAPE_IS_NOT_A_CYLINDER").arg(aName)); return false; } } } } + else if (aType == SMESH::FT_CoplanarFaces) + { + QString faceID; + myTable->GetThreshold(i, faceID); + if ( faceID.isEmpty() ) + { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("FACE_ID_NOT_SELECTED")); + return false; + } + if ( myMesh->_is_nil() ) + { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("MESH_IS_NOT_SELECTED")); + return false; + } + if ( myMesh->GetElementType( faceID.toLong(), /*iselem=*/true) != SMESH::FACE ) + { + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("NOT_FACE_ID").arg(faceID)); + return false; + } + } } return true; @@ -2060,47 +3236,76 @@ bool SMESHGUI_FilterDlg::isValid() const //======================================================================= // name : SMESHGUI_FilterDlg::SetSourceWg -// Purpose : Set widget of parent dialog containing idsto be filtered if +// Purpose : Set widget of parent dialog containing ids to be filtered if // user select corresponding source radio button //======================================================================= -void SMESHGUI_FilterDlg::SetSourceWg( QWidget* theWg ) +void SMESHGUI_FilterDlg::SetSourceWg (QWidget* theWg, + const bool initOnApply) { mySourceWg = theWg; + myInitSourceWgOnApply = initOnApply; +} + +//======================================================================= +//function : EnableFiltering +//purpose : Enables "Insert filter in the viewer" +// and different "Source"s (Mesh, Initial Selection, Current Group) +//======================================================================= + +void SMESHGUI_FilterDlg::SetEnabled( bool setInViewer, bool diffSources ) +{ + myInsertEnabled = setInViewer; + myDiffSourcesEnabled = diffSources; + + mySetInViewer->setVisible( myInsertEnabled ); + mySourceGrp->button(0)->parentWidget()->setVisible( myDiffSourcesEnabled ); } //======================================================================= -// name : SMESHGUI_FilterDlg::SetGroupIds +// name : SMESHGUI_FilterDlg::SetMesh // Purpose : Set mesh //======================================================================= -void SMESHGUI_FilterDlg::SetMesh( SMESH::SMESH_Mesh_ptr theMesh ) +void SMESHGUI_FilterDlg::SetMesh (SMESH::SMESH_Mesh_var theMesh) { - myMesh = theMesh; + if ( !theMesh->_is_nil() ) { + myMesh = theMesh; + if ( !myFilter[ myTable->GetType() ]->_is_nil()) + myFilter[ myTable->GetType() ]->SetMesh( theMesh ); + } + const bool isEnable = !(myMesh->_is_nil()); + myButtons[BTN_OK]->setEnabled(isEnable); + myButtons[BTN_Apply]->setEnabled(isEnable); +} + +//======================================================================= +// name : SMESHGUI_FilterDlg::SetGroup +// Purpose : Set a group being edited +//======================================================================= +void SMESHGUI_FilterDlg::SetGroup(SMESH::SMESH_GroupOnFilter_var group) +{ + myGroup = group; } //======================================================================= // name : SMESHGUI_FilterDlg::SetSelection // Purpose : Get filtered ids //======================================================================= -void SMESHGUI_FilterDlg::SetSelection( SALOME_Selection* theSel ) +void SMESHGUI_FilterDlg::SetSelection() { - if ( mySelection ) - disconnect( mySelection, SIGNAL( currentSelectionChanged() ), this, SLOT( onSelectionDone() ) ); - - mySelection = theSel; + if (mySelectionMgr) + disconnect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(onSelectionDone())); - if ( mySelection ) - { + if (mySelectionMgr) { myIObjects.Clear(); - const SALOME_ListIO& anObjs = mySelection->StoredIObjects(); - SALOME_ListIteratorOfListIO anIter( anObjs ); - for ( ;anIter.More(); anIter.Next() ) - { + const SALOME_ListIO& anObjs = mySelector->StoredIObjects(); + SALOME_ListIteratorOfListIO anIter (anObjs); + for ( ; anIter.More(); anIter.Next()) { TColStd_IndexedMapOfInteger aMap; - mySelection->GetIndex( anIter.Value(), aMap ); - myIObjects.Bind( anIter.Value(), aMap ); + mySelector->GetIndex(anIter.Value(), aMap); + myIObjects.Bind(anIter.Value(), aMap); } - - connect( mySelection, SIGNAL( currentSelectionChanged() ), SLOT( onSelectionDone() ) ); + + connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(onSelectionDone())); updateSelection(); } @@ -2115,35 +3320,42 @@ void SMESHGUI_FilterDlg::SetSelection( SALOME_Selection* theSel ) //======================================================================= bool SMESHGUI_FilterDlg::onApply() { - if ( !isValid() ) + if (!isValid()) return false; - try - { + SUIT_OverrideCursor wc; + try { int aCurrType = myTable->GetType(); - if ( !createFilter( aCurrType ) ) + if (!createFilter(aCurrType)) return false; insertFilterInViewer(); - if ( !myFilter[ aCurrType ]->GetPredicate()->_is_nil() ) - { - QValueList aResultIds; - filterSource( aCurrType, aResultIds ); - selectInViewer( aCurrType, aResultIds ); + if (!myFilter[ aCurrType ]->GetPredicate()->_is_nil()) { + // + bool toFilter = (( SMESH::FindActorByObject( myMesh )) || + ( myInitSourceWgOnApply && mySourceWg ) || + ( mySourceGrp->checkedId() == Dialog && mySourceWg )); + if ( toFilter ) { + QList aResultIds; + filterSource(aCurrType, aResultIds); + // select in viewer + selectInViewer(aCurrType, aResultIds); + } } myInsertState[ aCurrType ] = mySetInViewer->isChecked(); - myApplyToState[ aCurrType ] = mySourceGrp->id( mySourceGrp->selected() ); - + myApplyToState[ aCurrType ] = mySourceGrp->checkedId(); } - catch( const SALOME::SALOME_Exception& S_ex ) + catch(const SALOME::SALOME_Exception& S_ex) { - QtCatchCorbaException( S_ex ); + SalomeApp_Tools::QtCatchCorbaException(S_ex); + return false; } - catch( ... ) + catch(...) { + return false; } return true; @@ -2153,60 +3365,109 @@ bool SMESHGUI_FilterDlg::onApply() // name : SMESHGUI_FilterDlg::createFilter // Purpose : Create predicate for given type //======================================================================= -bool SMESHGUI_FilterDlg::createFilter( const int theType ) +bool SMESHGUI_FilterDlg::createFilter (const int theType) { SMESH::FilterManager_var aFilterMgr = SMESH::GetFilterManager(); - if ( aFilterMgr->_is_nil() ) + if (aFilterMgr->_is_nil()) return false; int n = myTable->NumRows(); SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria; - aCriteria->length( n ); + aCriteria->length(n); long aPrecision = -1; - if ( QAD_CONFIG->hasSetting( "SMESH:ControlsPrecision" ) ) - { - QString aStr = QAD_CONFIG->getSetting( "SMESH:ControlsPrecision" ); - bool isOk = false; - int aVal = aStr.toInt( &isOk ); - if ( isOk ) - aPrecision = aVal; - } - - for ( CORBA::ULong i = 0; i < n; i++ ) - { + SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( mySMESHGUI ); + + if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) ) + aPrecision = mgr->integerValue( "SMESH", "controls_precision", aPrecision ); + + for (CORBA::ULong i = 0; i < n; i++) { SMESH::Filter::Criterion aCriterion = createCriterion(); - myTable->GetCriterion( i, aCriterion ); + myTable->GetCriterion(i, aCriterion); aCriterion.Precision = aPrecision; aCriteria[ i ] = aCriterion; } + if ( !myFilter[ theType ]->_is_nil() ) + myFilter[ theType ]->UnRegister(); myFilter[ theType ] = aFilterMgr->CreateFilter(); - myFilter[ theType ]->SetCriteria( aCriteria.inout() ); + myFilter[ theType ]->SetCriteria(aCriteria.inout()); return true; } +//================================================================================ +/*! + * \brief Return the current filter + */ +//================================================================================ + +SMESH::Filter_var SMESHGUI_FilterDlg::GetFilter() const +{ + SMESH::Filter_var filter; + try { + int aCurrType = myTable->GetType(); + filter = myFilter[ aCurrType ]; + } + catch(...) + { + } + return filter._retn(); +} + +//================================================================================ +/*! + * \brief Sets a filter to the table + */ +//================================================================================ + +void SMESHGUI_FilterDlg::SetFilter(SMESH::Filter_var filter, int type) +{ + if ( !filter->_is_nil() ) + filter->Register(); + if ( !myFilter[ type ]->_is_nil() ) + myFilter[ type ]->UnRegister(); + + myFilter[ type ] = filter; +} + +//================================================================================ +/*! + * \brief call UnRegister() for myFilter's + */ +//================================================================================ + +void SMESHGUI_FilterDlg::UnRegisterFilters() +{ + QMap< int, SMESH::Filter_var >::iterator i_f = myFilter.begin(); + for ( ; i_f != myFilter.end(); ++i_f ) + if ( !i_f.value()->_is_nil() ) + i_f.value()->UnRegister(); + myFilter.clear(); +} + //======================================================================= // name : SMESHGUI_FilterDlg::insertFilterInViewer // Purpose : Insert filter in viewer //======================================================================= void SMESHGUI_FilterDlg::insertFilterInViewer() { - if ( VTKViewer_InteractorStyleSALOME* aStyle = SMESH::GetInteractorStyle() ) - { + if (SVTK_Selector* aSelector = SMESH::GetSelector()) { SMESH::ElementType anEntType = (SMESH::ElementType)myTable->GetType(); - if ( myFilter[ myTable->GetType() ]->_is_nil() || - myFilter[ myTable->GetType() ]->GetPredicate()->_is_nil() || - !mySetInViewer->isChecked() ) - SMESH::RemoveFilter( getFilterId( anEntType ), aStyle ); - else + if (myFilter[ myTable->GetType() ]->_is_nil() || + myFilter[ myTable->GetType() ]->GetPredicate()->_is_nil() || + !mySetInViewer->isChecked() || + !myInsertEnabled ) { + SMESH::RemoveFilter(getFilterId(anEntType), aSelector); + } + else { Handle(SMESHGUI_PredicateFilter) aFilter = new SMESHGUI_PredicateFilter(); - aFilter->SetPredicate( myFilter[ myTable->GetType() ]->GetPredicate() ); - SMESH::SetFilter( aFilter, aStyle ); + aFilter->SetPredicate(myFilter[ myTable->GetType() ]->GetPredicate()); + SMESH::RemoveFilter(getFilterId(anEntType), aSelector); //skl for IPAL12631 + SMESH::SetFilter(aFilter, aSelector); } } } @@ -2215,34 +3476,34 @@ void SMESHGUI_FilterDlg::insertFilterInViewer() // name : SMESHGUI_FilterDlg::filterSource // Purpose : Filter source ids //======================================================================= -void SMESHGUI_FilterDlg::filterSource( const int theType, - QValueList& theResIds ) +void SMESHGUI_FilterDlg::filterSource (const int theType, + QList& theResIds) { theResIds.clear(); - if ( myFilter[ theType ]->_is_nil() ) + if (myFilter[ theType ]->_is_nil()) return; - int aSourceId = mySourceGrp->id( mySourceGrp->selected() ); + int aSourceId = mySourceGrp->checkedId(); - if ( aSourceId == Mesh ) + if (aSourceId == Mesh || !myDiffSourcesEnabled ) { - if ( myMesh->_is_nil() ) + if (myMesh->_is_nil()) return; - SMESH::long_array_var anIds = myFilter[ theType ]->GetElementsId( myMesh ); - for ( int i = 0, n = anIds->length(); i < n; i++ ) - theResIds.append( anIds[ i ] ); + SMESH::long_array_var anIds = myFilter[ theType ]->GetElementsId(myMesh); + for (int i = 0, n = anIds->length(); i < n; i++) + theResIds.append(anIds[ i ]); } - else if ( aSourceId == Selection ) + else if (aSourceId == Selection) { - filterSelectionSource( theType, theResIds ); + filterSelectionSource(theType, theResIds); } - else if ( aSourceId == Dialog ) + else if (aSourceId == Dialog) { // retrieve ids from dialog - QValueList aDialogIds; - getIdsFromWg( mySourceWg, aDialogIds ); + QList aDialogIds; + getIdsFromWg(mySourceWg, aDialogIds); - if ( myMesh->_is_nil() ) + if (myMesh->_is_nil()) { theResIds = aDialogIds; return; @@ -2250,72 +3511,72 @@ void SMESHGUI_FilterDlg::filterSource( const int theType, // filter ids SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate(); - aPred->SetMesh( myMesh ); - QValueList::const_iterator anIter; - for ( anIter = aDialogIds.begin(); anIter != aDialogIds.end(); ++ anIter ) - if ( aPred->IsSatisfy( *anIter ) ) - theResIds.append( *anIter ); - - // set ids to the dialog - setIdsToWg( mySourceWg, theResIds ); + myFilter[ theType ]->SetMesh(myMesh); + QList::const_iterator anIter; + for (anIter = aDialogIds.begin(); anIter != aDialogIds.end(); ++ anIter) + if (aPred->IsSatisfy(*anIter)) + theResIds.append(*anIter); } + // set ids to the dialog + if (myInitSourceWgOnApply || aSourceId == Dialog) + setIdsToWg(mySourceWg, theResIds); } //======================================================================= // name : SMESHGUI_FilterDlg::filterSelectionSource // Purpose : Filter source selection //======================================================================= -void SMESHGUI_FilterDlg::filterSelectionSource( const int theType, - QValueList& theResIds ) +void SMESHGUI_FilterDlg::filterSelectionSource (const int theType, + QList& theResIds) { theResIds.clear(); - if ( myMesh->_is_nil() || mySelection == 0 ) + if (myMesh->_is_nil() || mySelectionMgr == 0) return; // Create map of entities to be filtered TColStd_MapOfInteger aToBeFiltered; - SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter( myIObjects ); + SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter(myIObjects); - for ( ; anIter.More(); anIter.Next() ) + for ( ; anIter.More(); anIter.Next()) { // process sub mesh - SMESH::SMESH_subMesh_var aSubMesh = SMESH::IObjectToInterface( anIter.Key() ); - if ( !aSubMesh->_is_nil() ) + SMESH::SMESH_subMesh_var aSubMesh = SMESH::IObjectToInterface(anIter.Key()); + if (!aSubMesh->_is_nil()) { - if ( aSubMesh->GetFather()->GetId() == myMesh->GetId() ) + if (aSubMesh->GetFather()->GetId() == myMesh->GetId()) { SMESH::long_array_var anIds = theType == SMESH::NODE ? aSubMesh->GetNodesId() : aSubMesh->GetElementsId(); - for ( int i = 0, n = anIds->length(); i < n; i++ ) - aToBeFiltered.Add( anIds[ i ] ); + for (int i = 0, n = anIds->length(); i < n; i++) + aToBeFiltered.Add(anIds[ i ]); } } // process group SMESH::SMESH_GroupBase_var aGroup = - SMESH::IObjectToInterface( anIter.Key() ); - if ( !aGroup->_is_nil() ) + SMESH::IObjectToInterface(anIter.Key()); + if (!aGroup->_is_nil()) { - if ( aGroup->GetType() == theType && aGroup->GetMesh()->GetId() == myMesh->GetId() ) + if (aGroup->GetType() == theType && aGroup->GetMesh()->GetId() == myMesh->GetId()) { SMESH::long_array_var anIds = aGroup->GetListOfID(); - for ( int i = 0, n = anIds->length(); i < n; i++ ) - aToBeFiltered.Add( anIds[ i ] ); + for (int i = 0, n = anIds->length(); i < n; i++) + aToBeFiltered.Add(anIds[ i ]); } } // process mesh - SMESH::SMESH_Mesh_var aMeshPtr = SMESH::IObjectToInterface( anIter.Key() ); - if ( !aMeshPtr->_is_nil() && aMeshPtr->GetId() == myMesh->GetId() ) + SMESH::SMESH_Mesh_var aMeshPtr = SMESH::IObjectToInterface(anIter.Key()); + if (!aMeshPtr->_is_nil() && aMeshPtr->GetId() == myMesh->GetId()) { const TColStd_IndexedMapOfInteger& aSelMap = anIter.Value(); - if ( aSelMap.Extent() > 0 ) + if (aSelMap.Extent() > 0) { - if(SMESH_Actor *anActor = SMESH::FindActorByEntry( anIter.Key()->getEntry() ) ) + if(SMESH::FindActorByEntry(anIter.Key()->getEntry())) { - for ( int i = 1; i <= aSelMap.Extent(); i++ ) - aToBeFiltered.Add( aSelMap(i) ); + for (int i = 1; i <= aSelMap.Extent(); i++) + aToBeFiltered.Add(aSelMap(i)); } } } @@ -2323,67 +3584,70 @@ void SMESHGUI_FilterDlg::filterSelectionSource( const int theType, // Filter entities SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate(); - aPred->SetMesh( myMesh ); - TColStd_MapIteratorOfMapOfInteger aResIter( aToBeFiltered ); - for ( ; aResIter.More(); aResIter.Next() ) - if ( aPred->IsSatisfy( aResIter.Key() ) ) - theResIds.append( aResIter.Key() ); + myFilter[ theType ]->SetMesh(myMesh); + TColStd_MapIteratorOfMapOfInteger aResIter(aToBeFiltered); + for ( ; aResIter.More(); aResIter.Next()) + if (aPred->IsSatisfy(aResIter.Key())) + theResIds.append(aResIter.Key()); } //======================================================================= // name : SMESHGUI_FilterDlg::selectInViewer // Purpose : Select given entities in viewer //======================================================================= -void SMESHGUI_FilterDlg::selectInViewer( const int theType, const QValueList& theIds ) +void SMESHGUI_FilterDlg::selectInViewer (const int theType, const QList& theIds) { - if ( mySelection == 0 || myMesh->_is_nil() ) + if (mySelectionMgr == 0 || myMesh->_is_nil()) return; - mySelection->ClearFilters(); + mySelectionMgr->clearFilters(); // Set new selection mode if necessary - Selection_Mode aSelMode = getSelMode( theType ); - if ( aSelMode != mySelection->SelectionMode() ) - { - mySelection->ClearIObjects(); - mySelection->ClearFilters(); - if ( aSelMode == NodeSelection ) - SMESH::SetPointRepresentation(true); - QAD_Application::getDesktop()->SetSelectionMode( aSelMode ); + Selection_Mode aSelMode = getSelMode(theType); + SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ); + if ( aViewWindow && aViewWindow->SelectionMode()!=aSelMode) { + mySelectionMgr->clearSelected(); + mySelectionMgr->clearFilters(); + SMESH::SetPointRepresentation( aSelMode == NodeSelection ); + aViewWindow->SetSelectionMode(aSelMode); } // Clear selection SMESH_Actor* anActor = SMESH::FindActorByObject(myMesh); - if ( !anActor || !anActor->hasIO() ) + if (!anActor || !anActor->hasIO()) return; Handle(SALOME_InteractiveObject) anIO = anActor->getIO(); - mySelection->ClearIObjects(); - mySelection->AddIObject( anIO, false ); + //mySelectionMgr->clearSelected(); + //mySelectionMgr->AddIObject(anIO, false); + SALOME_ListIO aList; + aList.Append(anIO); + mySelectionMgr->setSelectedObjects(aList, false); // Remove filter corresponding to the current type from viewer int aType = myTable->GetType(); - int aFilterId = SMESHGUI_UnknownFilter; - if ( aType == SMESH::EDGE ) aFilterId = SMESHGUI_EdgeFilter; - else if ( aType == SMESH::FACE ) aFilterId = SMESHGUI_FaceFilter; - else if ( aType == SMESH::VOLUME ) aFilterId = SMESHGUI_VolumeFilter; - Handle(VTKViewer_Filter) aFilter = SMESH::GetFilter( aFilterId ); - SMESH::RemoveFilter( aFilterId ); + int aFilterId = SMESH::UnknownFilter; + if (aType == SMESH::EDGE ) aFilterId = SMESH::EdgeFilter; + else if (aType == SMESH::FACE ) aFilterId = SMESH::FaceFilter; + else if (aType == SMESH::VOLUME) aFilterId = SMESH::VolumeFilter; + Handle(VTKViewer_Filter) aFilter = SMESH::GetFilter(aFilterId); + SMESH::RemoveFilter(aFilterId); // get vtk ids TColStd_MapOfInteger aMap; - QValueList::const_iterator anIter; - for ( anIter = theIds.begin(); anIter != theIds.end(); ++anIter ) - { - aMap.Add( *anIter ); + QList::const_iterator anIter; + for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter) { + aMap.Add(*anIter); } // Set new selection - mySelection->AddOrRemoveIndex( anIO, aMap, false, true ); + mySelector->AddOrRemoveIndex(anIO, aMap, false); + if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) + aViewWindow->highlight( anIO, true, true ); // insert previously stored filter in viewer if necessary - if ( !aFilter.IsNull() ) - SMESH::SetFilter( aFilter ); + if (!aFilter.IsNull()) + SMESH::SetFilter(aFilter); } //======================================================================= @@ -2394,12 +3658,13 @@ SMESH::Filter::Criterion SMESHGUI_FilterDlg::createCriterion() { SMESH::Filter::Criterion aCriterion; - aCriterion.Type = FT_Undefined; - aCriterion.Compare = FT_Undefined; + aCriterion.Type = SMESH::FT_Undefined; + aCriterion.Compare = SMESH::FT_Undefined; aCriterion.Threshold = 0; - aCriterion.UnaryOp = FT_Undefined; - aCriterion.BinaryOp = FT_Undefined; + aCriterion.UnaryOp = SMESH::FT_Undefined; + aCriterion.BinaryOp = SMESH::FT_Undefined; aCriterion.ThresholdStr = ""; + aCriterion.ThresholdID = ""; aCriterion.TypeOfElement = SMESH::ALL; return aCriterion; @@ -2413,34 +3678,115 @@ SMESH::Filter::Criterion SMESHGUI_FilterDlg::createCriterion() //======================================================================= void SMESHGUI_FilterDlg::onSelectionDone() { + const SALOME_ListIO& aList = mySelector->StoredIObjects(); + if ( myMesh->_is_nil() && aList.Extent()>0 ) + { + myMesh = SMESH::IObjectToInterface(aList.First()); + if ( !(myMesh->_is_nil()) ) { + myButtons[BTN_OK]->setEnabled(true); + myButtons[BTN_Apply]->setEnabled(true); + } + } int aRow, aCol; - if ( mySelection->IObjectCount() != 1 || - !myTable->CurrentCell( aRow, aCol ) || - myTable->GetCriterionType( aRow ) != FT_BelongToGeom && - myTable->GetCriterionType( aRow ) != FT_BelongToPlane && - myTable->GetCriterionType( aRow ) != FT_BelongToCylinder) + if (aList.Extent() != 1 || !myTable->CurrentCell(aRow, aCol)) + return; + + const int type = myTable->GetCriterionType(aRow); + QList types; + types << SMESH::FT_BelongToGeom << SMESH::FT_BelongToPlane + << SMESH::FT_BelongToCylinder << SMESH::FT_BelongToGenSurface + << SMESH::FT_LyingOnGeom << SMESH::FT_CoplanarFaces + << SMESH::FT_ConnectedElements << SMESH::FT_BelongToMeshGroup; + if ( !types.contains( type )) return; - Handle(SALOME_InteractiveObject) anIO = mySelection->firstIObject() ; - GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface( anIO ) ; - if ( !anObj->_is_nil() ) - myTable->SetThreshold( aRow, anIO->getName() ); + Handle(SALOME_InteractiveObject) anIO = aList.First(); + switch ( type ) + { + case SMESH::FT_CoplanarFaces: // get ID of a selected mesh face + { + QString aString; + int nbElems = SMESH::GetNameOfSelectedElements(mySelector, anIO, aString); + if (nbElems == 1) + myTable->SetThreshold(aRow, aString); + break; + } + case SMESH::FT_ConnectedElements: // get either VERTEX or a node ID + { + GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface(anIO); + if (!anObj->_is_nil()) + { + myTable->SetThreshold(aRow, GEOMBase::GetName(anObj)); + myTable->SetID (aRow, anIO->getEntry()); + } + else + { + QString aString; + int nbElems = SMESH::GetNameOfSelectedElements(mySelector, anIO, aString); + if (nbElems == 1) + myTable->SetThreshold(aRow, aString); + } + break; + } + case SMESH::FT_BelongToMeshGroup: // get a group Name and Entry + { + SMESH::SMESH_GroupBase_var grp = SMESH::IObjectToInterface(anIO); + if ( !grp->_is_nil() ) + { + if ( !myMesh->_is_nil() ) + { + SMESH::SMESH_Mesh_var mesh = grp->GetMesh(); + if ( ! myMesh->_is_equivalent( mesh )) + return; + } + if ( !myGroup->_is_nil() && myGroup->IsInDependency( grp )) + return; // avoid cyclic dependencies between Groups on Filter + + myTable->SetThreshold(aRow, SMESH::toQStr( grp->GetName() )); + myTable->SetID (aRow, anIO->getEntry() ); + } + } + default: // get a GEOM object + { + GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface(anIO); + if (!anObj->_is_nil()) + { + myTable->SetThreshold(aRow, GEOMBase::GetName(anObj)); + myTable->SetID (aRow, anIO->getEntry()); + } + } + } } + //======================================================================= // name : SMESHGUI_FilterDlg::onCriterionChanged // Purpose : SLOT called when cretarion of current row changed. Update selection //======================================================================= -void SMESHGUI_FilterDlg::onCriterionChanged( const int , const int ) +void SMESHGUI_FilterDlg::onCriterionChanged (const int, const int) { updateSelection(); } +//======================================================================= +// name : SMESHGUI_FilterDlg::onThresholdChanged +// Purpose : SLOT called when a threshold value is changed by the user and +// not by myTable->SetThreshold() +//======================================================================= +void SMESHGUI_FilterDlg::onThresholdChanged( const int row, const int type ) +{ + if ( myTable->GetCriterionType( row, type ) == SMESH::FT_ConnectedElements ) + { + // to differ the text entered by the user from that got from selection + myTable->SetID( row, "", type ); + } +} + //======================================================================= // name : SMESHGUI_FilterDlg::onCurrentChanged // Purpose : SLOT called when current row changed. Update selection //======================================================================= -void SMESHGUI_FilterDlg::onCurrentChanged( int, int ) +void SMESHGUI_FilterDlg::onCurrentChanged (int, int) { updateSelection(); } @@ -2451,54 +3797,123 @@ void SMESHGUI_FilterDlg::onCurrentChanged( int, int ) //======================================================================= void SMESHGUI_FilterDlg::updateSelection() { - if ( mySelection == 0 ) + if (mySelectionMgr == 0) return; - - mySelection->ClearFilters(); + +// TColStd_MapOfInteger allTypes; +// for( int i=0; i<10; i++ ) +// allTypes.Add( i ); + SalomeApp_Study* aStudy = dynamic_cast( mySMESHGUI->application()->activeStudy() ); + if( !aStudy ) + return; + + restoreSelMode(); + + mySelectionMgr->clearFilters(); int aRow, aCol; - if ( myTable->CurrentCell( aRow, aCol ) && - ( myTable->GetCriterionType( aRow ) == FT_BelongToGeom || - myTable->GetCriterionType( aRow ) == FT_BelongToPlane || - myTable->GetCriterionType( aRow ) == FT_BelongToCylinder ) ) - { - if ( myTable->GetCriterionType( aRow ) == FT_BelongToGeom ) - mySelection->AddFilter( new SALOME_TypeFilter( "GEOM" ) ); - else if ( myTable->GetCriterionType( aRow ) == FT_BelongToPlane ) - mySelection->AddFilter( new GEOM_FaceFilter( StdSelect_Plane ) ); - else if ( myTable->GetCriterionType( aRow ) == FT_BelongToCylinder ) - mySelection->AddFilter( new GEOM_FaceFilter( StdSelect_Cylinder ) ); - + bool isCurrentCell = myTable->CurrentCell(aRow, aCol); + int aCriterionType = myTable->GetCriterionType(aRow); + if ( isCurrentCell && + (aCriterionType == SMESH::FT_BelongToGeom || + aCriterionType == SMESH::FT_BelongToPlane || + aCriterionType == SMESH::FT_BelongToCylinder || + aCriterionType == SMESH::FT_BelongToGenSurface || + aCriterionType == SMESH::FT_LyingOnGeom)) + { + if (aCriterionType == SMESH::FT_BelongToGeom || + aCriterionType == SMESH::FT_BelongToGenSurface || + aCriterionType == SMESH::FT_LyingOnGeom) { + + mySelectionMgr->installFilter(new GEOM_SelectionFilter( aStudy, true )); + + } else if (aCriterionType == SMESH::FT_BelongToPlane) { + mySelectionMgr->installFilter(new GEOM_FaceFilter( aStudy, StdSelect_Plane ) ); + + } else if (aCriterionType == SMESH::FT_BelongToCylinder) { + mySelectionMgr->installFilter(new GEOM_FaceFilter( aStudy, StdSelect_Cylinder ) ); + } myIsSelectionChanged = true; + } - else + else if ( aCriterionType == SMESH::FT_BelongToMeshGroup ) { - if ( myIsSelectionChanged ) - mySelection->AddFilter( new SALOME_TypeFilter( "This filter deactivate selection" ) ); + SMESH_TypeFilter* typeFilter = 0; + switch ( myTable->GetType() ) + { + case SMESH::NODE : typeFilter = new SMESH_TypeFilter( SMESH::GROUP_NODE ); break; + case SMESH::ELEM0D : typeFilter = new SMESH_TypeFilter( SMESH::GROUP_0D ); break; + case SMESH::BALL : typeFilter = new SMESH_TypeFilter( SMESH::GROUP_BALL ); break; + case SMESH::EDGE : typeFilter = new SMESH_TypeFilter( SMESH::GROUP_EDGE ); break; + case SMESH::FACE : typeFilter = new SMESH_TypeFilter( SMESH::GROUP_FACE ); break; + case SMESH::VOLUME : typeFilter = new SMESH_TypeFilter( SMESH::GROUP_VOLUME ); break; + case SMESH::ALL : typeFilter = new SMESH_TypeFilter( SMESH::GROUP ); break; + default : typeFilter = 0; + } + if ( typeFilter ) + mySelectionMgr->installFilter( typeFilter ); } -} - - - - - - - - - - - - - - - - + else if ( aCriterionType == SMESH::FT_ConnectedElements ) + { + QList fList; + fList.push_back( new SMESH_NumberFilter( "GEOM", TopAbs_SHAPE, 1, TopAbs_VERTEX )); + fList.push_back( new SMESH_TypeFilter( SMESH::IDSOURCE )); + mySelectionMgr->installFilter + ( new SMESH_LogicalFilter( fList, SMESH_LogicalFilter::LO_OR, + !mySelectionMgr->autoDeleteFilter() )); + if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) + { + mySelModeToRestore = aViewWindow->SelectionMode(); + aViewWindow->SetSelectionMode( NodeSelection ); + myToRestoreSelMode = ( mySelModeToRestore != NodeSelection ); + if ( myToRestoreSelMode ) + SMESH::SetPointRepresentation( true ); + } + } + else + { + mySelector->SetSelectionMode( getSelMode( myTable->GetType() )); + if (myIsSelectionChanged) { + // mySelectionMgr->installFilter( new GEOM_TypeFilter( aStudy, -1 ) ); // This filter deactivates selection + // Impossible to select any object in the OB on the second opening of FilterDlg + } + } +} +//================================================================================= +// function : keyPressEvent() +// purpose : +//================================================================================= +void SMESHGUI_FilterDlg::keyPressEvent( QKeyEvent* e ) +{ + QDialog::keyPressEvent( e ); + if ( e->isAccepted() ) + return; + if ( e->key() == Qt::Key_F1 ) { + e->accept(); + onHelp(); + } +} +//================================================================================ +/*! + * \brief Restores a selection mode if it was changed to set up some criterion + */ +//================================================================================ +void SMESHGUI_FilterDlg::restoreSelMode() +{ + if ( myToRestoreSelMode ) + { + SMESH::SetPointRepresentation( mySelModeToRestore == NodeSelection ); + if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) + aViewWindow->SetSelectionMode( mySelModeToRestore ); + myToRestoreSelMode = false; + } +}