X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_FilterDlg.cxx;h=97f1df847d47671462c6830e5880de2cc680197a;hp=49d6ff7958aef493981cf9e0bbc59d007e455ea7;hb=c4cacfb5c15254953d6a1ce60a2196e099c91a9a;hpb=b33324fe602b1fe1158c14a866c3802df12370fa diff --git a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx index 49d6ff795..97f1df847 100755 --- a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx +++ b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx @@ -1,30 +1,31 @@ -// 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 +// 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. +// 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. +// 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 +// 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" @@ -33,35 +34,46 @@ #include "SMESHGUI_Filter.h" #include "SMESHGUI_FilterUtils.h" #include "SMESHGUI_FilterLibraryDlg.h" +#include "SMESHGUI_SpinBox.h" #include "SMESH_Actor.h" #include "SMESH_NumberFilter.hxx" #include "SMESH_TypeFilter.hxx" - -#include "GEOMBase.h" -#include "GEOM_FaceFilter.h" -#include "GEOM_TypeFilter.h" - -#include "SUIT_Desktop.h" -#include "SUIT_ResourceMgr.h" - -#include "SalomeApp_Application.h" -#include "SalomeApp_Tools.h" -#include "SalomeApp_Study.h" - -#include "SALOME_ListIO.hxx" -#include "SALOME_ListIteratorOfListIO.hxx" -#include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx" -#include "SALOMEDSClient_Study.hxx" - -#include "SVTK_ViewWindow.h" -#include "SVTK_Selector.h" - -// OCCT Includes +#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 @@ -70,57 +82,63 @@ #include #include -// QT Includes -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// IDL Headers -#include "SALOMEconfig.h" +// 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 5 -#define MARGIN 10 - -using namespace SMESH; +#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())); + aRes = qMax(aRes, theMetrics.width(anIter.value())); return aRes; } +//--------------------------------------- +// getFilterId +//--------------------------------------- static int getFilterId (SMESH::ElementType 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; } } @@ -129,59 +147,62 @@ 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); + 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) + : 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); - QHBoxLayout* aLay = new QHBoxLayout(this, 0, SPACING); - aLay->addWidget(aLabel); - aLay->addWidget(myLineEdits[ Tolerance ]); + 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; - QSpacerItem* aSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum); - aLay->addItem(aSpacer); + QHBoxLayout* aLay = new QHBoxLayout(this); + aLay->setSpacing(SPACING); + aLay->setMargin(0); - QString aText = QString("%1").arg(Precision::Confusion()); - myLineEdits[ Tolerance ]->setText(aText); + aLay->addWidget(aLabel); + aLay->addWidget(myWidgets[ Tolerance ]); + aLay->addStretch(); + + SetDouble( Tolerance, Precision::Confusion() ); } - SMESHGUI_FilterTable::AdditionalWidget::~AdditionalWidget() +SMESHGUI_FilterTable::AdditionalWidget::~AdditionalWidget() { } -void SMESHGUI_FilterTable::AdditionalWidget::GetParameters (QValueList& theList) const +QList SMESHGUI_FilterTable::AdditionalWidget::GetParameters() const { - theList.clear(); + QList theList; theList.append(Tolerance); + return theList; } bool SMESHGUI_FilterTable::AdditionalWidget::IsValid (const bool theMsg) const @@ -189,17 +210,21 @@ bool SMESHGUI_FilterTable::AdditionalWidget::IsValid (const bool theMsg) const if (!isEnabled()) return true; - QValueList aParams; - GetParameters(aParams); - QValueList::const_iterator anIter; + QList aParams = GetParameters(); + QList::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::desktop(), tr("SMESH_INSUFFICIENT_DATA"), - tr("SMESHGUI_INVALID_PARAMETERS"), QMessageBox::Ok); + 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; } } @@ -209,50 +234,99 @@ bool SMESHGUI_FilterTable::AdditionalWidget::IsValid (const bool theMsg) const double SMESHGUI_FilterTable::AdditionalWidget::GetDouble (const int theId) const { - return myLineEdits.contains(theId) ? myLineEdits[ theId ]->text().toDouble() : 0; + 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().toInt() : 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; } QString SMESHGUI_FilterTable::AdditionalWidget::GetString (const int theId) const { - return myLineEdits.contains(theId) ? myLineEdits[ theId ]->text() : QString(""); + 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; } void SMESHGUI_FilterTable::AdditionalWidget::SetDouble (const int theId, const double 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( 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::SetString (const int theId, const QString& theVal) { - if (myLineEdits.contains(theId)) - myLineEdits[ theId ]->setText(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::SetEditable (const int theId, const bool isEditable) { - if (myLineEdits.contains(theId)) - myLineEdits[ theId ]->setEdited(isEditable); + 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 bool isEditable) { - QValueList aParams; - GetParameters(aParams); - QValueList::const_iterator anIter; + QList aParams = GetParameters(); + QList::const_iterator anIter; for (anIter = aParams.begin(); anIter != aParams.end(); ++anIter) - myLineEdits[ *anIter ]->setEdited(isEditable); + SetEditable( *anIter, isEditable ); +} + +void SMESHGUI_FilterTable::AdditionalWidget::SetPrecision(const int theId, const char* precision) +{ + 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 ) ); + } + } } /* @@ -260,83 +334,398 @@ 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& ); - int GetValue() const; - void SetValue(const int); + void setItems( const QMap& ); + void clear(); + int count() const; + + int value() const; + void setValue( const int ); private: + int id( int ) const; + int index( int ) const; - QMap myNumToId; - QMap myIdToNum; +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 ); +} - setStringList(aList); +int SMESHGUI_FilterTable::ComboItem::count() const +{ + return myIdToIdx.count(); +} + +int SMESHGUI_FilterTable::ComboItem::value() const +{ + return( id( data( Qt::UserRole ).toStringList().indexOf( text() ) ) ); } -SMESHGUI_FilterTable::ComboItem::~ComboItem() +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::GetValue() const +int SMESHGUI_FilterTable::ComboItem::id( int idx ) const { - return myNumToId[ currentItem() ]; + 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. +*/ + +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; +} + +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 ) ) +{ +} + +SMESHGUI_FilterTable::ComboDelegate::~ComboDelegate() +{ +} + +QWidget* SMESHGUI_FilterTable::ComboDelegate::createEditor( QWidget* parent, + const QStyleOptionViewItem& option, + const QModelIndex& index ) const +{ + 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::ComboItem::SetValue (const int theVal) +void SMESHGUI_FilterTable::ComboDelegate::setModelData( QWidget* editor, + QAbstractItemModel* model, + const QModelIndex& index) const { - setCurrentItem(myIdToNum[ theVal ]); + 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 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(); - void SetEditable(const bool state, const int row, const int col); - bool IsEditable(const int row, const int col) const; + QSize minimumSizeHint() const; - virtual void insertRows(int row, int count = 1); - virtual QString text(int row, int col) const; + void setEditable( bool, int, int ); + bool isEditable( int, int ) const; + + void setReadOnly( bool ); + bool isReadOnly() const; + + void insertRows( int, int = 1 ); + QString text( int, int ); + + QList selectedRows(); }; //======================================================================= @@ -344,44 +733,89 @@ public: // Purpose : Constructor //======================================================================= SMESHGUI_FilterTable::Table::Table (QWidget* parent) -: QTable(parent, "SMESHGUI_FilterTable::Table") +: QTableWidget(parent) { + // set custom item delegate + setItemDelegate( new ComboDelegate(this) ); + // set edit triggers by default + setReadOnly( false ); } +//======================================================================= +// name : SMESHGUI_FilterTable::Table::Table +// Purpose : Constructor +//======================================================================= SMESHGUI_FilterTable::Table::Table (int numRows, int numCols, QWidget* parent) -: QTable(numRows, numCols, parent, "SMESHGUI_FilterTable::Table") +: 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 +{ + QTableWidgetItem* anItem = item( row, col ); + return anItem == 0 || anItem->flags() & Qt::ItemIsEditable; +} + +void SMESHGUI_FilterTable::Table::setReadOnly( bool on ) { - QTableItem* anItem = item(row, col); - return anItem == 0 || anItem->editType() != QTableItem::Never; + setEditTriggers( on ? + QAbstractItemView::NoEditTriggers : + QAbstractItemView::AllEditTriggers ); +} + +bool SMESHGUI_FilterTable::Table::isReadOnly() const +{ + return editTriggers() == QAbstractItemView::NoEditTriggers; } //======================================================================= @@ -390,30 +824,35 @@ bool SMESHGUI_FilterTable::Table::IsEditable (const int row, const int col) cons //======================================================================= 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) //======================================================================= -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(); + closePersistentEditor( currentItem() ); + QTableWidgetItem* anItem = item( row, col ); + return anItem ? anItem->text() : QString(); +} - if (anEditRow >= 0 && anEditCol >= 0 && anEditRow == row && anEditCol == col) - ((Table*)this)->endEdit(row, col, true, false); +QList SMESHGUI_FilterTable::Table::selectedRows() +{ + QList selItems = selectedItems(); + QTableWidgetItem* anItem; + QList rows; - return QTable::text(row, col); -} + foreach( anItem, selItems ) { + int r = row( anItem ); + if ( !rows.contains( r ) ) rows.append( r ); + } + qSort( rows ); + return rows; +} /* Class : SMESHGUI_FilterTable @@ -428,14 +867,17 @@ QString SMESHGUI_FilterTable::Table::text (int row, int col) const // Purpose : Constructor //======================================================================= SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule, - QWidget* parent, - const int type) -: QFrame(parent), + QWidget* parent, + const int type ) +: QWidget( parent ), myIsLocked( false ), mySMESHGUI( theModule ) { myEntityType = -1; - Init(type); + + QList aTypes; + aTypes.append(type); + Init(aTypes); } //======================================================================= @@ -443,9 +885,9 @@ SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule, // Purpose : Constructor //======================================================================= SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule, - QWidget* parent, - const QValueList& types) -: QFrame(parent), + QWidget* parent, + const QList& types ) +: QWidget( parent ), myIsLocked( false ), mySMESHGUI( theModule ) { @@ -461,18 +903,7 @@ SMESHGUI_FilterTable::~SMESHGUI_FilterTable() // name : SMESHGUI_FilterTable::Init // Purpose : Create table corresponding to the specified type //======================================================================= -void SMESHGUI_FilterTable::Init (const int type) -{ - 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()) return; @@ -481,42 +912,51 @@ void SMESHGUI_FilterTable::Init (const QValueList& theTypes) if (myTables.isEmpty()) { - int aType = theTypes.first(); - // 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); + 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) { - 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 = 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); @@ -529,23 +969,28 @@ void SMESHGUI_FilterTable::Init (const QValueList& theTypes) 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())); @@ -555,42 +1000,53 @@ void SMESHGUI_FilterTable::Init (const QValueList& theTypes) connect(myCopyFromBtn, SIGNAL(clicked()), this, SLOT(onCopyFromBtn())); connect(myAddToBtn, SIGNAL(clicked()), this, SLOT(onAddToBtn())); - connect(myEntityTypeGrp, SIGNAL(clicked(int)), this, SLOT(onEntityType(int))); + 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 ]); + myEntityType = -1; + } + } + } // Hide buttons of entity types if necessary const QMap& aSupportedTypes = getSupportedTypes(); QMap::const_iterator 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) { - QFrame* aFrame = new QFrame(theParent); + QWidget* aFrame = new QWidget(theParent); QFrame* aLine1 = new QFrame(aFrame); QFrame* aLine2 = new QFrame(aFrame); @@ -601,13 +1057,15 @@ QWidget* SMESHGUI_FilterTable::createAdditionalFrame (QWidget* theParent) 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; } @@ -635,18 +1093,20 @@ void SMESHGUI_FilterTable::onEntityType (int theType) emit NeedValidation(); if (!myIsValid) { - myEntityTypeGrp->setButton(myEntityType); + myEntityTypeGrp->button(myEntityType)->setChecked(true); return; } myEntityType = theType; - if (!myTables.contains(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(); + anIter.value()->setVisible( myEntityType == anIter.key() ); updateBtnState(); qApp->processEvents(); @@ -654,7 +1114,6 @@ void SMESHGUI_FilterTable::onEntityType (int theType) adjustSize(); emit EntityTypeChanged(theType); - } //======================================================================= @@ -666,45 +1125,50 @@ bool SMESHGUI_FilterTable::IsValid (const bool theMess, const int theEntityType) 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 || - aCriterion == FT_LyingOnGeom) { - if (aTable->text(i, 2).isEmpty()) { - if (theMess) - QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), - tr("ERROR"), QMessageBox::Ok); - return false; - } - } else { + QString errMsg; + if (aCriterion == SMESH::FT_GroupColor ) + { + QtxColorButton* clrBtn = qobject_cast(aTable->cellWidget(i, 2)); + if (clrBtn && !clrBtn->color().isValid()) + errMsg = tr( "GROUPCOLOR_ERROR" ); + } + 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; + bool isSignalsBlocked = aTable->signalsBlocked(); aTable->blockSignals(true); double aThreshold = (int)aTable->text(i, 2).toDouble(&aRes); - aTable->blockSignals(false); + aTable->blockSignals(isSignalsBlocked); - if (!aRes && aTable->IsEditable(i, 2)) { - if (theMess) - QMessageBox::information(SMESHGUI::desktop(), 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::desktop(), tr("SMESH_INSUFFICIENT_DATA"), - tr("MULTIEDGES_ERROR"), QMessageBox::Ok); - return false; - } + if (!aRes && aTable->isEditable(i, 2)) + errMsg = tr( "ERROR" ); } - QTableItem* anItem = aTable->item(i, 0); + if (!errMsg.isEmpty()) { + if (theMess) + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), errMsg ); + return false; + } + + QTableWidgetItem* anItem = aTable->item(i, 0); if (myAddWidgets.contains(anItem) && !myAddWidgets[ anItem ]->IsValid()) return false; } @@ -736,7 +1200,7 @@ int SMESHGUI_FilterTable::GetType() const //======================================================================= void SMESHGUI_FilterTable::SetType (const int type) { - myEntityTypeGrp->setButton(type); + myEntityTypeGrp->button(type)->setChecked(true); onEntityType(type); } @@ -758,7 +1222,7 @@ int SMESHGUI_FilterTable::GetCriterionType (const int theRow, const int theType) int aType = theType == -1 ? GetType() : theType; Table* aTable = myTables[ aType ]; ComboItem* anItem = (ComboItem*)aTable->item(theRow, 0); - return anItem != 0 ? anItem->GetValue() : FT_Undefined; + return anItem != 0 ? anItem->value() : SMESH::FT_Undefined; } //======================================================================= @@ -772,27 +1236,74 @@ void SMESHGUI_FilterTable::GetCriterion (const int theRow, 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; + 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 && - aCriterionType != FT_LyingOnGeom) + 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.Threshold = (double)((ComboItem*)aTable->item(theRow, 2))->value(); + } + else if ( aCriterionType == SMESH::FT_CoplanarFaces ) { - theCriterion.Compare = ((ComboItem*)aTable->item(theRow, 1))->GetValue(); + 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); + QTableWidgetItem* anItem = aTable->item(theRow, 0); if (myAddWidgets.contains(anItem)) theCriterion.Tolerance = myAddWidgets[ anItem ]->GetDouble(AdditionalWidget::Tolerance); } @@ -809,47 +1320,119 @@ void SMESHGUI_FilterTable::SetCriterion (const int theRow, Table* aTable = myTables[ aType ]; - if (theRow > aTable->numRows() - 1) + if (theRow > aTable->rowCount() - 1) return; - ((ComboItem*)aTable->item(theRow, 0))->SetValue(theCriterion.Type); + ((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); + 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); - - if (theCriterion.Type != FT_RangeOfIds && - theCriterion.Type != FT_BelongToGeom && - theCriterion.Type != FT_BelongToPlane && - theCriterion.Type != FT_BelongToCylinder && - theCriterion.Type != FT_LyingOnGeom) - aTable->setText(theRow, 2, QString("%1").arg(theCriterion.Threshold, 0, 'g', 15)); + aTable->setEditable(false, theRow, 4); + + 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); + QTableWidgetItem* anItem = aTable->item(theRow, 0); if (!myAddWidgets.contains(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); } emit CriterionChanged(theRow, aType); - } //======================================================================= @@ -860,7 +1443,7 @@ void SMESHGUI_FilterTable::Update() { Table* aTable = myTables[ GetType() ]; int aCurrRow = aTable->currentRow(); - int numRows = aTable->numRows(); + int numRows = aTable->rowCount(); if ((aCurrRow < 0 || aCurrRow >= numRows) && numRows > 0) aTable->setCurrentCell(0, 0); updateAdditionalWidget(); @@ -876,7 +1459,7 @@ void SMESHGUI_FilterTable::AddCriterion (const SMESH::Filter::Criterion& theCrit int aType = theEntityType == -1 ? GetType() : theEntityType; Table* aTable = myTables[ aType ]; addRow(aTable, aType); - SetCriterion(aTable->numRows() - 1, theCriterion); + SetCriterion(aTable->rowCount() - 1, theCriterion); } //======================================================================= @@ -885,7 +1468,7 @@ void SMESHGUI_FilterTable::AddCriterion (const SMESH::Filter::Criterion& theCrit //======================================================================= int SMESHGUI_FilterTable::NumRows (const int theEntityType) const { - return myTables[ theEntityType == -1 ? GetType() : theEntityType ]->numRows(); + return myTables[ theEntityType == -1 ? GetType() : theEntityType ]->rowCount(); } //======================================================================= @@ -895,12 +1478,12 @@ int SMESHGUI_FilterTable::NumRows (const int theEntityType) const 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); @@ -941,25 +1524,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(); } @@ -972,41 +1552,96 @@ 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); 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_LyingOnGeom && - GetCriterionType(aRow) != FT_RangeOfIds && - GetCriterionType(aRow) != FT_FreeEdges && - GetCriterionType(aRow) != FT_BadOrientedVolume; + 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->raiseWidget(myWgStack->id(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; +} + //======================================================================= // name : SMESHGUI_FilterTable::removeAdditionalWidget // 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); + QTableWidgetItem* anItem = theTable->item(theRow, 0); if (myAddWidgets.contains(anItem)) { myWgStack->removeWidget(myAddWidgets[ anItem ]); - myAddWidgets[ anItem ]->reparent(0, QPoint()); + myAddWidgets[ anItem ]->setParent(0); delete myAddWidgets[ anItem ]; myAddWidgets.remove(anItem); } @@ -1019,12 +1654,12 @@ 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); @@ -1044,53 +1679,325 @@ void SMESHGUI_FilterTable::onCurrentChanged (int theRow, int theCol) 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) { int aType = entityType == -1 ? GetType() : entityType; Table* aTable = myTables[ aType ]; ComboItem* aCompareItem = (ComboItem*)aTable->item(row, 1); - int aCriterionType = GetCriterionType(row); + // 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() ); + } - if (aType == SMESH::EDGE && aCriterionType == SMESH::FT_FreeBorders || - aType == SMESH::FACE && aCriterionType == SMESH::FT_FreeEdges || - aType == SMESH::VOLUME && aCriterionType == SMESH::FT_BadOrientedVolume) + // 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 ) { - if (aCompareItem->count() > 0) - aCompareItem->setStringList(QStringList()); - aTable->SetEditable(false, row, 2); + 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 ); } - else if (aCriterionType == SMESH::FT_RangeOfIds || - aCriterionType == SMESH::FT_BelongToGeom || - aCriterionType == SMESH::FT_BelongToPlane || - aCriterionType == SMESH::FT_BelongToCylinder || - aCriterionType == SMESH::FT_LyingOnGeom) + + // check if the current item type satisfies the criterion + bool itemTypeKO = + ( aCriterionType == SMESH::FT_GroupColor && !clrBtn) || + ( anIsComboCriterion && !isComboItem ) || + ( anIsIntCriterion && !isIntSpinItem ) || + ( anIsDoubleCriterion && !isDoubleSpinItem ); + + if ( !itemTypeKO ) { - QMap aMap; - aMap[ FT_EqualTo ] = tr("EQUAL_TO"); - aCompareItem->setStringList(aMap); - if (!aTable->IsEditable(row, 2)) - aTable->SetEditable(true, row, 2); + 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 ); + } } - else + + // update the table row + + bool isSignalsBlocked = aTable->signalsBlocked(); + aTable->blockSignals( true ); + + // update threshold table item + if ( itemTypeKO ) { - if (aCompareItem->count() != 3) + aTable->removeCellWidget( row, 2 ); + + if ( aCriterionType == SMESH::FT_GroupColor ) // ---------------------- QtxColorButton { - aCompareItem->setStringList(QStringList()); - aCompareItem->setStringList(getCompare()); + 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() ); + } + } + + // set Compare + if ( anIsDoubleCriterion ) + nbCompareSigns = 3; + if ( aCompareItem->count() != nbCompareSigns ) + { + 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(); @@ -1104,7 +2011,10 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con //======================================================================= 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()); } //======================================================================= @@ -1113,13 +2023,12 @@ 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; } //======================================================================= @@ -1135,8 +2044,8 @@ void SMESHGUI_FilterTable::addRow (Table* theTable, const int theType, const boo myIsLocked = true; if (toTheEnd || aSelectedRow == -1) { - theTable->insertRows(theTable->numRows()); - aCurrRow = theTable->numRows() - 1; + theTable->insertRows(theTable->rowCount()); + aCurrRow = theTable->rowCount() - 1; } else { @@ -1145,40 +2054,49 @@ void SMESHGUI_FilterTable::addRow (Table* theTable, const int theType, const boo } 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 NOT - theTable->setItem(aCurrRow, 3, getUnaryItem(theTable)); + // Logical operation AND / OR + theTable->setItem(aCurrRow, 4, new QTableWidgetItem()); + + theTable->setItem(aCurrRow, 5, new QTableWidgetItem()); + + theTable->blockSignals( isSignalsBlocked ); // 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 ) anAddBinOpStr = aCurrRow; if (theTable->item(aCurrRow, 4) == 0 || - theTable->item(aCurrRow, 4)->rtti() != 1) + theTable->item(aCurrRow, 4)->type() != ComboItem::Type()) { - - if (anAddBinOpStr >= 0 && (theTable->item(anAddBinOpStr, 4) == 0 || - theTable->item(anAddBinOpStr, 4)->rtti() != 1)) - theTable->setItem(anAddBinOpStr, 4, getBinaryItem(theTable)); + 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->setEditable(false, theTable->rowCount() - 1, 4); + + if (aCurrRow >=0 && aCurrRow < theTable->rowCount() && + aCurrCol >=0 && aCurrCol < theTable->rowCount()) theTable->setCurrentCell(aCurrRow, aCurrCol); onCriterionChanged(aCurrRow, 0); @@ -1190,25 +2108,25 @@ 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()) @@ -1217,16 +2135,16 @@ QTableItem* SMESHGUI_FilterTable::getBinaryItem (QTable* theParent) 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")); } //======================================================================= @@ -1239,9 +2157,12 @@ const QMap& SMESHGUI_FilterTable::getSupportedTypes() const if (aTypes.isEmpty()) { 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; @@ -1258,11 +2179,17 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) static QMap aCriteria; 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_LyingOnGeom ] = tr("LYING_ON_GEOM"); + 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; } @@ -1271,14 +2198,22 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) static QMap aCriteria; 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_LyingOnGeom ] = tr("LYING_ON_GEOM"); + 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; } @@ -1287,20 +2222,33 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) static QMap aCriteria; 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_LyingOnGeom ] = tr("LYING_ON_GEOM"); - aCriteria[ SMESH::FT_Length2D ] = tr("LENGTH2D"); - aCriteria[ SMESH::FT_MultiConnection2D] = tr("MULTI2D_BORDERS"); + 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; } @@ -1309,17 +2257,89 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) static QMap aCriteria; if (aCriteria.isEmpty()) { - aCriteria[ SMESH::FT_AspectRatio3D] = tr("ASPECT_RATIO_3D"); - aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS"); - 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_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; } } @@ -1351,9 +2371,9 @@ SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* thePar 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()); @@ -1366,10 +2386,10 @@ SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* thePar const QMap& aSupportedTypes = getSupportedTypes(); QMap::const_iterator anIter; for (anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter) - aMaxLenCr = Max(maxLength(getCriteria(anIter.key()), aMetrics), aMaxLenCr); + aMaxLenCr = qMax(maxLength(getCriteria(anIter.key()), aMetrics), aMaxLenCr); } - static int aLenCr = abs( aMaxLenCr - + static int aLenCr = qAbs( aMaxLenCr - aMetrics.width(tr("CRITERION"))) / aMetrics.width(' ') + 5; QString aCrStr; @@ -1377,15 +2397,21 @@ SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* thePar 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") + " "); - + 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); + aTable->resizeColumnToContents(i); + + // set the ID column invisible + aTable->hideColumn( 5 ); aTable->updateGeometry(); QSize aSize = aTable->sizeHint(); @@ -1393,12 +2419,12 @@ SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* thePar aTable->setMinimumSize(QSize(aWidth, aWidth / 2)); aTable->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding)); - connect(aTable, SIGNAL(valueChanged(int, int)), - this, SLOT(onCriterionChanged(int, int))); - - 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; } @@ -1408,8 +2434,8 @@ 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); } //======================================================================= @@ -1421,7 +2447,22 @@ void SMESHGUI_FilterTable::SetEditable (const bool isEditable) TableMap::iterator 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) { @@ -1439,9 +2480,9 @@ void SMESHGUI_FilterTable::SetEditable (const bool isEditable) } } - QMap::iterator anIter2; + QMap::iterator anIter2; for (anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2) - anIter2.data()->SetEditable(isEditable); + anIter2.value()->SetEditable(isEditable); } //======================================================================= @@ -1458,9 +2499,9 @@ void SMESHGUI_FilterTable::SetEnabled (const bool isEnabled) if (isEnabled) updateBtnState(); - QMap::iterator anIter2; + QMap::iterator anIter2; for (anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2) - anIter2.data()->setEnabled(isEnabled); + anIter2.value()->setEnabled(isEnabled); } //======================================================================= @@ -1566,7 +2607,13 @@ void SMESHGUI_FilterTable::SetThreshold (const int theRow, 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); } //======================================================================= @@ -1578,7 +2625,7 @@ bool SMESHGUI_FilterTable::GetThreshold (const int theRow, const int theEntityType) { Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ]; - QTableItem* anItem = aTable->item(theRow, 2); + QTableWidgetItem* anItem = aTable->item(theRow, 2); if (anItem != 0) { theText = anItem->text(); @@ -1588,6 +2635,37 @@ bool SMESHGUI_FilterTable::GetThreshold (const int theRow, 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 @@ -1598,17 +2676,18 @@ bool SMESHGUI_FilterTable::GetThreshold (const int theRow, // name : SMESHGUI_FilterDlg::SMESHGUI_FilterDlg // Purpose : Constructor //======================================================================= -SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule, - const QValueList& theTypes, - const char* theName) -: QDialog( SMESH::GetDesktop( theModule ), theName, false, - WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu), - mySMESHGUI( theModule ), - mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ) +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 ) { if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) mySelector = aViewWindow->GetSelector(); - + construct(theTypes); } @@ -1617,16 +2696,17 @@ SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule, // Purpose : Constructor //======================================================================= SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule, - const int theType, - const char* theName) -: QDialog( SMESH::GetDesktop( theModule ), theName, false, - WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu), - mySMESHGUI( theModule ), - mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ) + const int theType ) +: QDialog( SMESH::GetDesktop( theModule ) ), + mySMESHGUI( theModule ), + mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ), + myInitSourceWgOnApply( true ), + myInsertEnabled( true ), + myDiffSourcesEnabled( true ) { if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) mySelector = aViewWindow->GetSelector(); - QValueList aTypes; + QList aTypes; aTypes.append(theType); construct(aTypes); } @@ -1635,22 +2715,28 @@ SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule, // name : SMESHGUI_FilterDlg::construct // 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, MARGIN, SPACING); + QVBoxLayout* aDlgLay = new QVBoxLayout (this); + aDlgLay->setMargin(MARGIN); + aDlgLay->setSpacing(SPACING); - myMainFrame = createMainFrame (this); - QFrame* aBtnFrame = createButtonFrame(this); + myMainFrame = createMainFrame (this); + QWidget* aBtnFrame = createButtonFrame(this); aDlgLay->addWidget(myMainFrame); aDlgLay->addWidget(aBtnFrame); aDlgLay->setStretchFactor(myMainFrame, 1); + myHelpFileName = "selection_filter_library_page.html"; + Init(myTypes); } @@ -1658,25 +2744,34 @@ void SMESHGUI_FilterDlg::construct (const QValueList& theTypes) // 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( mySMESHGUI, aMainFrame, myTypes ); myTable->SetLibsEnabled(true); - QFrame* aLine = new QFrame(myTable->GetTableGrp()); + QGroupBox* aGrp = myTable->GetTableGrp(); + QGridLayout* aLay = qobject_cast( aGrp->layout() ); + int rows = aLay->rowCount(); + int cols = aLay->columnCount(); + + // 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"), myTable->GetTableGrp()); + 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(CriterionChanged(const int, const int)), SLOT(onCriterionChanged(const int, const int))); @@ -1684,6 +2779,9 @@ QFrame* SMESHGUI_FilterDlg::createMainFrame (QWidget* theParent) connect(myTable, SIGNAL(CurrentChanged(int, int)), SLOT(onCurrentChanged(int, int))); + aMainLay->addWidget(myTable); + aMainLay->addWidget(aSourceGrp); + return aMainFrame; } @@ -1691,21 +2789,30 @@ 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; } //======================================================================= @@ -1714,19 +2821,15 @@ QButtonGroup* SMESHGUI_FilterDlg::createSourceGroup (QWidget* theParent) //======================================================================= void SMESHGUI_FilterDlg::updateMainButtons() { + 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(); } @@ -1734,23 +2837,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); - - myButtons[ BTN_OK ] = new QPushButton(tr("SMESH_BUT_OK" ), aGrp); - myButtons[ BTN_Apply ] = new QPushButton(tr("SMESH_BUT_APPLY"), aGrp); + QGroupBox* aGrp = new QGroupBox(theParent); + QHBoxLayout* aLay = new QHBoxLayout(aGrp); + aLay->setMargin(MARGIN); + aLay->setSpacing(SPACING); - QLabel* aLbl = new QLabel(aGrp); - aLbl->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + 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); - myButtons[ BTN_Cancel ] = new QPushButton(tr("SMESH_BUT_CANCEL"), aGrp); - myButtons[ BTN_Close ] = new QPushButton(tr("SMESH_BUT_CLOSE"), aGrp); + 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 ]); 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_Close ], SIGNAL(clicked()), SLOT(reject())); connect(myButtons[ BTN_Apply ], SIGNAL(clicked()), SLOT(onApply())); + connect(myButtons[ BTN_Help ], SIGNAL(clicked()), SLOT(onHelp())); updateMainButtons(); @@ -1769,24 +2879,31 @@ 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; + QList aTypes; aTypes.append(type); - Init(aTypes); + 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) { + if ( theTypes.empty() ) + { + Init( SMESH::ALL, setInViewer ); + return; + } mySourceWg = 0; myTypes = theTypes; myMesh = SMESH::SMESH_Mesh::_nil(); + myGroup = SMESH::SMESH_GroupOnFilter::_nil(); myIObjects.Clear(); myIsSelectionChanged = false; + myToRestoreSelMode = false; myTable->Init(theTypes); @@ -1794,13 +2911,16 @@ void SMESHGUI_FilterDlg::Init (const QValueList& theTypes) 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(); @@ -1810,17 +2930,15 @@ void SMESHGUI_FilterDlg::Init (const QValueList& theTypes) mySMESHGUI->SetActiveDialogBox((QDialog*)this); connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(onDeactivate())); - connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(onClose())); - - int x, y; - mySMESHGUI->DefineDlgPosition(this, x, y); - this->move(x, y); - + connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject())); + connect(mySMESHGUI, SIGNAL(SignalActivatedViewManager()), SLOT(onOpenView())); + connect(mySMESHGUI, SIGNAL(SignalCloseView()), SLOT(onCloseView())); + updateMainButtons(); updateSelection(); // Initialise filter table with values of previous filter - QValueList::const_iterator anIter; + QList::const_iterator anIter; for (anIter = theTypes.begin(); anIter != theTypes.end(); ++anIter) { myTable->Clear(*anIter); @@ -1838,11 +2956,11 @@ void SMESHGUI_FilterDlg::Init (const QValueList& theTypes) 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); } //======================================================================= @@ -1854,6 +2972,7 @@ void SMESHGUI_FilterDlg::onOk() { if (onApply()) { + restoreSelMode(); mySelectionMgr->clearFilters(); disconnect(mySMESHGUI, 0, this, 0); disconnect(mySelectionMgr, 0, this, 0); @@ -1864,11 +2983,12 @@ void SMESHGUI_FilterDlg::onOk() } //======================================================================= -// 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 (mySelectionMgr) { @@ -1876,7 +2996,7 @@ void SMESHGUI_FilterDlg::onClose() mySelectionMgr->clearFilters(); mySelectionMgr->clearSelected(); SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter (myIObjects); - for (; anIter.More(); anIter.Next()) + for ( ; anIter.More(); anIter.Next()) { aList.Append(anIter.Key()); @@ -1887,7 +3007,7 @@ void SMESHGUI_FilterDlg::onClose() mySelector->AddOrRemoveIndex( anIter.Key(), aResMap, false); if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) - aViewWindow->highlight( anIter.Key(), true, true ); + aViewWindow->highlight( anIter.Key(), true, true ); } mySelectionMgr->setSelectedObjects(aList, false); } @@ -1895,8 +3015,54 @@ void SMESHGUI_FilterDlg::onClose() disconnect(mySMESHGUI, 0, this, 0); disconnect(mySelectionMgr, 0, this, 0); mySMESHGUI->ResetState(); - reject(); - return; + QDialog::reject(); +} + +//================================================================================= +// function : onOpenView() +// purpose : +//================================================================================= +void SMESHGUI_FilterDlg::onOpenView() +{ + if ( mySelector ) { + SMESH::SetPointRepresentation(false); + } + else { + mySelector = SMESH::GetViewWindow( mySMESHGUI )->GetSelector(); + } +} + +//================================================================================= +// function : onCloseView() +// purpose : +//================================================================================= +void SMESHGUI_FilterDlg::onCloseView() +{ + mySelector = 0; +} + +//================================================================================= +// 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)); + } } //======================================================================= @@ -1920,46 +3086,37 @@ void SMESHGUI_FilterDlg::enterEvent (QEvent*) setEnabled(true); } -//======================================================================= -// name : closeEvent() -// Purpose : -//======================================================================= -void SMESHGUI_FilterDlg::closeEvent (QCloseEvent*) -{ - onClose(); -} - //======================================================================= // 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) 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++) { - int anId = aListBox->text(i).toInt(&b); + int anId = aListBox->item(i)->text().toInt(&b); if (b) theRes.append(anId); } } else if (theWg->inherits("QLineEdit")) { - QLineEdit* aLineEdit = (QLineEdit*)theWg; + const QLineEdit* aLineEdit = qobject_cast( theWg ); QString aStr = aLineEdit->text(); QRegExp aRegExp("(\\d+)"); bool b; int aPos = 0; while (aPos >= 0) { - aPos = aRegExp.search(aStr, aPos); + aPos = aRegExp.indexIn(aStr, aPos); if (aPos > -1) { int anId = aRegExp.cap(1).toInt(&b); @@ -1980,9 +3137,12 @@ Selection_Mode SMESHGUI_FilterDlg::getSelMode (const int theType) const 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; } @@ -1992,36 +3152,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) 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")) { - 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(" ")); } } @@ -2037,56 +3184,82 @@ bool SMESHGUI_FilterDlg::isValid() const 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 || - aType == FT_LyingOnGeom) { + 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); std::vector<_PTR(SObject)> aList = - SMESH::GetActiveStudyDocument()->FindObjectByName(aName.latin1(), "GEOM"); + SMESH::GetActiveStudyDocument()->FindObjectByName(aName.toLatin1().constData(), "GEOM"); if (aList.size() == 0) { - QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), - tr("BAD_SHAPE_NAME").arg(aName), QMessageBox::Ok); + SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), + tr("BAD_SHAPE_NAME").arg(aName)); return false; } - if (aType == FT_BelongToCylinder || aType == FT_BelongToPlane) { - CORBA::Object_var anObject = SMESH::SObjectToObject(aList[ 0 ]); - //GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(aList[ 0 ]->GetObject()); + 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) || aFace.IsNull() || aFace.ShapeType() != TopAbs_FACE) { - QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"), - tr("SHAPE_IS_NOT_A_FACE").arg(aName), QMessageBox::Ok); + 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::desktop(), tr("SMESH_INSUFFICIENT_DATA"), - tr("SHAPE_IS_NOT_A_FACE").arg(aName), QMessageBox::Ok); + 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::desktop(), 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::desktop(), 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; @@ -2094,21 +3267,54 @@ 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; } //======================================================================= @@ -2122,9 +3328,9 @@ void SMESHGUI_FilterDlg::SetSelection() if (mySelectionMgr) { myIObjects.Clear(); - const SALOME_ListIO& anObjs = mySelector->StoredIObjects(); + const SALOME_ListIO& anObjs = mySelector->StoredIObjects(); SALOME_ListIteratorOfListIO anIter (anObjs); - for (; anIter.More(); anIter.Next()) { + for ( ; anIter.More(); anIter.Next()) { TColStd_IndexedMapOfInteger aMap; mySelector->GetIndex(anIter.Value(), aMap); myIObjects.Bind(anIter.Value(), aMap); @@ -2148,6 +3354,7 @@ bool SMESHGUI_FilterDlg::onApply() if (!isValid()) return false; + SUIT_OverrideCursor wc; try { int aCurrType = myTable->GetType(); @@ -2157,20 +3364,32 @@ bool SMESHGUI_FilterDlg::onApply() insertFilterInViewer(); if (!myFilter[ aCurrType ]->GetPredicate()->_is_nil()) { - QValueList aResultIds; - filterSource(aCurrType, aResultIds); - selectInViewer(aCurrType, aResultIds); + // + bool toFilter = (( SMESH::FindActorByObject( myMesh )) || + ( myInitSourceWgOnApply && mySourceWg ) || + ( mySourceGrp->checkedId() == Dialog && mySourceWg )); + if ( toFilter ) { + QList aResultIds; + filterSource(aCurrType, aResultIds); + // select in viewer + selectInViewer(aCurrType, aResultIds); + // set ids to the dialog + if ( myInitSourceWgOnApply || mySourceGrp->checkedId() == Dialog ) + setIdsToWg(mySourceWg, aResultIds); + } } myInsertState[ aCurrType ] = mySetInViewer->isChecked(); - myApplyToState[ aCurrType ] = mySourceGrp->id(mySourceGrp->selected()); + myApplyToState[ aCurrType ] = mySourceGrp->checkedId(); } catch(const SALOME::SALOME_Exception& S_ex) { SalomeApp_Tools::QtCatchCorbaException(S_ex); + return false; } catch(...) { + return false; } return true; @@ -2204,29 +3423,85 @@ bool SMESHGUI_FilterDlg::createFilter (const int theType) aCriteria[ i ] = aCriterion; } + if ( !myFilter[ theType ]->_is_nil() ) + myFilter[ theType ]->UnRegister(); myFilter[ theType ] = aFilterMgr->CreateFilter(); 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 (SVTK_InteractorStyle* 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 { + 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); + SMESH::RemoveFilter(getFilterId(anEntType), aSelector); //skl for IPAL12631 + SMESH::SetFilter(aFilter, aSelector); } } } @@ -2236,15 +3511,15 @@ void SMESHGUI_FilterDlg::insertFilterInViewer() // Purpose : Filter source ids //======================================================================= void SMESHGUI_FilterDlg::filterSource (const int theType, - QValueList& theResIds) + QList& theResIds) { theResIds.clear(); 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()) return; @@ -2259,7 +3534,7 @@ void SMESHGUI_FilterDlg::filterSource (const int theType, else if (aSourceId == Dialog) { // retrieve ids from dialog - QValueList aDialogIds; + QList aDialogIds; getIdsFromWg(mySourceWg, aDialogIds); if (myMesh->_is_nil()) @@ -2270,14 +3545,11 @@ void SMESHGUI_FilterDlg::filterSource (const int theType, // filter ids SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate(); - aPred->SetMesh(myMesh); - QValueList::const_iterator anIter; + 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 - setIdsToWg(mySourceWg, theResIds); } } @@ -2286,7 +3558,7 @@ void SMESHGUI_FilterDlg::filterSource (const int theType, // Purpose : Filter source selection //======================================================================= void SMESHGUI_FilterDlg::filterSelectionSource (const int theType, - QValueList& theResIds) + QList& theResIds) { theResIds.clear(); if (myMesh->_is_nil() || mySelectionMgr == 0) @@ -2296,7 +3568,7 @@ void SMESHGUI_FilterDlg::filterSelectionSource (const int theType, TColStd_MapOfInteger aToBeFiltered; 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()); @@ -2343,9 +3615,9 @@ void SMESHGUI_FilterDlg::filterSelectionSource (const int theType, // Filter entities SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate(); - aPred->SetMesh(myMesh); + myFilter[ theType ]->SetMesh(myMesh); TColStd_MapIteratorOfMapOfInteger aResIter(aToBeFiltered); - for (; aResIter.More(); aResIter.Next()) + for ( ; aResIter.More(); aResIter.Next()) if (aPred->IsSatisfy(aResIter.Key())) theResIds.append(aResIter.Key()); } @@ -2354,7 +3626,7 @@ void SMESHGUI_FilterDlg::filterSelectionSource (const int theType, // 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 (mySelectionMgr == 0 || myMesh->_is_nil()) return; @@ -2367,8 +3639,7 @@ void SMESHGUI_FilterDlg::selectInViewer (const int theType, const QValueListSelectionMode()!=aSelMode) { mySelectionMgr->clearSelected(); mySelectionMgr->clearFilters(); - if (aSelMode == NodeSelection) - SMESH::SetPointRepresentation(true); + SMESH::SetPointRepresentation( aSelMode == NodeSelection ); aViewWindow->SetSelectionMode(aSelMode); } @@ -2386,16 +3657,16 @@ void SMESHGUI_FilterDlg::selectInViewer (const int theType, const QValueListGetType(); - 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; + 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; + QList::const_iterator anIter; for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter) { aMap.Add(*anIter); } @@ -2418,12 +3689,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; @@ -2437,32 +3709,110 @@ SMESH::Filter::Criterion SMESHGUI_FilterDlg::createCriterion() //======================================================================= void SMESHGUI_FilterDlg::onSelectionDone() { - int aRow, aCol; 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 (aList.Extent() != 1 || !myTable->CurrentCell(aRow, aCol)) + return; - if (aList.Extent() != 1 || - !myTable->CurrentCell(aRow, aCol) || - myTable->GetCriterionType(aRow) != FT_BelongToGeom && - myTable->GetCriterionType(aRow) != FT_BelongToPlane && - myTable->GetCriterionType(aRow) != FT_BelongToCylinder && - myTable->GetCriterionType(aRow) != FT_LyingOnGeom) + 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 = aList.First(); - GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface(anIO); - if (!anObj->_is_nil()) - myTable->SetThreshold(aRow, GEOMBase::GetName(anObj)); + 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 @@ -2481,40 +3831,120 @@ void SMESHGUI_FilterDlg::updateSelection() if (mySelectionMgr == 0) return; - TColStd_MapOfInteger allTypes; - for( int i=0; i<10; i++ ) - allTypes.Add( i ); +// 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 || - myTable->GetCriterionType(aRow) == FT_LyingOnGeom)) { - - if (myTable->GetCriterionType(aRow) == FT_BelongToGeom || - myTable->GetCriterionType(aRow) == FT_LyingOnGeom) { + + 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 (myTable->GetCriterionType(aRow) == FT_BelongToPlane) { + } else if (aCriterionType == SMESH::FT_BelongToPlane) { mySelectionMgr->installFilter(new GEOM_FaceFilter( aStudy, StdSelect_Plane ) ); - } else if (myTable->GetCriterionType(aRow) == FT_BelongToCylinder) { + } else if (aCriterionType == SMESH::FT_BelongToCylinder) { mySelectionMgr->installFilter(new GEOM_FaceFilter( aStudy, StdSelect_Cylinder ) ); } myIsSelectionChanged = true; - } else { + } + else if ( aCriterionType == SMESH::FT_BelongToMeshGroup ) + { + 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 + // 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; + } +}