-// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003-2007 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.
//
-// 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
+// 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
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESHGUI : GUI for SMESH component
#include <LightApp_SelectionMgr.h>
#include <SalomeApp_Tools.h>
#include <SalomeApp_Study.h>
+#include <SalomeApp_IntSpinBox.h>
+#include <SalomeApp_DoubleSpinBox.h>
#include <SALOME_ListIO.hxx>
#include <SALOME_ListIteratorOfListIO.hxx>
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
const QStyleOptionViewItem& option,
const QModelIndex& index ) const
{
- QStringList l = index.data( Qt::UserRole ).toStringList();
- if ( !l.isEmpty() ) {
- QComboBox* cb = new QComboBox( parent );
- cb->setFrame( false );
- cb->addItems( l );
- return cb;
+ 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
{
- QString value = index.model()->data( index, Qt::DisplayRole ).toString();
- QComboBox* cb = dynamic_cast<QComboBox*>( editor );
+ QVariant data = index.model()->data( index, Qt::DisplayRole );
+ QString value = data.toString();
bool bOk = false;
- if ( cb ) {
+ if ( QComboBox* cb = dynamic_cast<QComboBox*>( editor ) ) {
int i = cb->findText( value );
if ( i >= 0 ) {
cb->setCurrentIndex( i );
bOk = true;
}
}
+ else if ( SalomeApp_DoubleSpinBox* dblSpin = dynamic_cast<SalomeApp_DoubleSpinBox*>( editor ) ) {
+ if( data.type() == QVariant::Double ) {
+ double valueDouble = data.toDouble( &bOk );
+ if( bOk )
+ dblSpin->setValue( valueDouble );
+ }
+ }
if ( !bOk ) QItemDelegate::setEditorData( editor, index );
}
QAbstractItemModel* model,
const QModelIndex& index) const
{
- QComboBox* cb = dynamic_cast<QComboBox*>( editor );
- if ( cb ) model->setData( index, cb->currentText(), Qt::DisplayRole );
+ if( QComboBox* cb = dynamic_cast<QComboBox*>( editor ) )
+ model->setData( index, cb->currentText(), Qt::DisplayRole );
+ else if( SalomeApp_IntSpinBox* intSpin = dynamic_cast<SalomeApp_IntSpinBox*>( editor ) )
+ model->setData( index, intSpin->value(), Qt::DisplayRole );
+ else if( SalomeApp_DoubleSpinBox* dblSpin = dynamic_cast<SalomeApp_DoubleSpinBox*>( editor ) )
+ model->setData( index, dblSpin->value(), Qt::DisplayRole );
else QItemDelegate::setModelData( editor, model, index );
}
((ComboItem*)aTable->item(theRow, 0))->setValue(theCriterion.Type);
onCriterionChanged(theRow, 0, aType);
- ((ComboItem*)aTable->item(theRow, 1))->setValue(theCriterion.Compare);
+ 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 != SMESH::FT_Undefined)
aTable->item( theRow, 2 )->setText( QString( theCriterion.ThresholdID ) );
}
else if (theCriterion.Type != SMESH::FT_RangeOfIds &&
- 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_CoplanarFaces &&
- 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)
+ 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_CoplanarFaces &&
+ 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)
{
aTable->item( theRow, 2 )->setText(QString("%1").arg(theCriterion.Threshold, 0, 'g', 15));
}
theCriterion.Type == SMESH::FT_BelongToGenSurface ||
theCriterion.Type == SMESH::FT_BelongToGeom ||
theCriterion.Type == SMESH::FT_LyingOnGeom ||
- theCriterion.Type == SMESH::FT_CoplanarFaces)
+ theCriterion.Type == SMESH::FT_CoplanarFaces ||
+ theCriterion.Type == SMESH::FT_EqualNodes)
{
QTableWidgetItem* anItem = aTable->item(theRow, 0);
if (!myAddWidgets.contains(anItem))
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:
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 );
}
return typeIds;
int aCriterionType = GetCriterionType(row);
QtxColorButton* clrBtn = qobject_cast<QtxColorButton*>(aTable->cellWidget(row, 2));
int aComboType = ComboItem::Type();
+ int aIntSpinType = IntSpinItem::Type();
+ int aDoubleSpinType = DoubleSpinItem::Type();
QTableWidgetItem* aTableItem = aTable->item(row, 2);
bool isComboItem = false;
+ bool isIntSpinItem = false;
+ bool isDoubleSpinItem = false;
if (aTableItem) {
int aTableType = aTable->item(row, 2)->type();
isComboItem = ( aTableType == aComboType );
+ isIntSpinItem = ( aTableType == aIntSpinType );
+ isDoubleSpinItem = ( aTableType == aDoubleSpinType );
}
+ bool anIsDoubleCriterion =
+ aCriterionType == SMESH::FT_AspectRatio ||
+ aCriterionType == SMESH::FT_AspectRatio3D ||
+ aCriterionType == SMESH::FT_Taper ||
+ aCriterionType == SMESH::FT_Warping ||
+ aCriterionType == SMESH::FT_MinimumAngle ||
+ aCriterionType == SMESH::FT_Skew ||
+ aCriterionType == SMESH::FT_Area ||
+ aCriterionType == SMESH::FT_Length ||
+ aCriterionType == SMESH::FT_Length2D ||
+ aCriterionType == SMESH::FT_MaxElementLength2D ||
+ aCriterionType == SMESH::FT_MaxElementLength3D ||
+ aCriterionType == SMESH::FT_Volume3D;
+
+ 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 );
+ }
+
+ // if the precision is to be changed we should remove the existing
+ // spin item and create another one with new precision
+ bool anIsPrecisionChanged = false;
+ if ( anIsDoubleCriterion && isDoubleSpinItem ) {
+ if ( DoubleSpinItem* aDoubleSpinItem = dynamic_cast<DoubleSpinItem*>( aTable->item( row, 2 ) ) ) {
+ anIsPrecisionChanged = aDoubleSpinItem->precision() != aPrecision;
+ }
+ }
+
if ( (aCriterionType != SMESH::FT_GroupColor && clrBtn) ||
- (aCriterionType != SMESH::FT_ElemGeomType && isComboItem) )
+ (aCriterionType != SMESH::FT_ElemGeomType && isComboItem) ||
+ (aCriterionType != SMESH::FT_MultiConnection && isIntSpinItem) ||
+ (!anIsDoubleCriterion && isDoubleSpinItem) ||
+ anIsPrecisionChanged )
{
bool isSignalsBlocked = aTable->signalsBlocked();
aTable->blockSignals( true );
aTable->blockSignals( isSignalsBlocked );
}
if ( (aCriterionType == SMESH::FT_GroupColor && !clrBtn) ||
- (aCriterionType == SMESH::FT_ElemGeomType && !isComboItem) )
+ (aCriterionType == SMESH::FT_ElemGeomType && !isComboItem) ||
+ (aCriterionType == SMESH::FT_MultiConnection && !isIntSpinItem) ||
+ (anIsDoubleCriterion && !isDoubleSpinItem) ||
+ anIsPrecisionChanged )
{
bool isSignalsBlocked = aTable->signalsBlocked();
aTable->blockSignals( true );
if ( aCriterionType == SMESH::FT_GroupColor )
aTable->setCellWidget( row, 2, new QtxColorButton( aTable ) );
- else {
+ else if ( aCriterionType == SMESH::FT_ElemGeomType ) {
QList<int> typeIds = geomTypes( aType );
QMap<int, QString> typeNames;
QList<int>::const_iterator anIter = typeIds.begin();
ComboItem* typeBox = new ComboItem( typeNames );
aTable->setItem( row, 2, typeBox );
}
+ else if ( aCriterionType == SMESH::FT_MultiConnection ) {
+ IntSpinItem* intSpin = new IntSpinItem( 0 );
+ aTable->setItem( row, 2, intSpin );
+ }
+ else if ( anIsDoubleCriterion ) {
+ DoubleSpinItem* dblSpin = new DoubleSpinItem( 0 );
+ dblSpin->setPrecision( aPrecision );
+ aTable->setItem( row, 2, dblSpin );
+ }
aTable->blockSignals( isSignalsBlocked );
}
- if ((aType == SMESH::NODE && aCriterionType == SMESH::FT_FreeNodes ) ||
- (aType == SMESH::EDGE && aCriterionType == SMESH::FT_FreeBorders ) ||
- (aType == SMESH::FACE && (aCriterionType == SMESH::FT_BareBorderFace ||
- aCriterionType == SMESH::FT_OverConstrainedFace ||
- aCriterionType == SMESH::FT_FreeEdges ||
- aCriterionType == SMESH::FT_FreeFaces)) ||
- (aType == SMESH::VOLUME && (aCriterionType == SMESH::FT_BadOrientedVolume ||
- aCriterionType == SMESH::FT_OverConstrainedVolume ||
- aCriterionType == SMESH::FT_BareBorderVolume)) ||
+ if ((aType == SMESH::NODE && (aCriterionType == SMESH::FT_FreeNodes ||
+ aCriterionType == SMESH::FT_EqualNodes )) ||
+ (aType == SMESH::EDGE && (aCriterionType == SMESH::FT_FreeBorders ||
+ aCriterionType == SMESH::FT_EqualEdges )) ||
+ (aType == SMESH::FACE && (aCriterionType == SMESH::FT_BareBorderFace ||
+ aCriterionType == SMESH::FT_OverConstrainedFace ||
+ aCriterionType == SMESH::FT_FreeEdges ||
+ aCriterionType == SMESH::FT_FreeFaces ||
+ aCriterionType == SMESH::FT_EqualFaces)) ||
+ (aType == SMESH::VOLUME && (aCriterionType == SMESH::FT_BadOrientedVolume ||
+ aCriterionType == SMESH::FT_OverConstrainedVolume ||
+ aCriterionType == SMESH::FT_BareBorderVolume ||
+ aCriterionType == SMESH::FT_EqualVolumes )) ||
aCriterionType == SMESH::FT_LinearOrQuadratic ||
aCriterionType == SMESH::FT_GroupColor ||
aCriterionType == SMESH::FT_ElemGeomType ||
if (aCompareItem->count() > 0)
aCompareItem->clear();
aTable->setEditable(false, row, 1);
+ aTable->item(row, 2)->setText( QString("") );
aTable->setEditable(aCriterionType == SMESH::FT_GroupColor ||
aCriterionType == SMESH::FT_ElemGeomType ||
aCriterionType == SMESH::FT_CoplanarFaces, row, 2);
//=======================================================================
void SMESHGUI_FilterTable::onCriterionChanged (int row, int col)
{
- onCriterionChanged(row, col, -1);
+ if( col == 0 )
+ onCriterionChanged(row, col, -1);
}
//=======================================================================
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");
}
return aCriteria;
}
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");
}
return aCriteria;
}
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");
}
return aCriteria;
}
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");
}
return aCriteria;
}
mySourceGrp->addButton(aSelBtn, Selection);
mySourceGrp->addButton(aDlgBtn, Dialog);
- aSelBtn->setChecked(true);
+ aMeshBtn->setChecked(true);
return aBox;
}
//=======================================================================
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();
}
myButtons[ BTN_OK ] = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), aGrp);
myButtons[ BTN_Apply ] = new QPushButton(tr("SMESH_BUT_APPLY"), aGrp);
- myButtons[ BTN_Cancel ] = new QPushButton(tr("SMESH_BUT_CANCEL"), aGrp);
myButtons[ BTN_Close ] = new QPushButton(tr("SMESH_BUT_CLOSE"), aGrp);
myButtons[ BTN_Help ] = new QPushButton(tr("SMESH_BUT_HELP"), aGrp);
aLay->addWidget(myButtons[ BTN_Apply ]);
aLay->addSpacing(10);
aLay->addStretch();
- aLay->addWidget(myButtons[ BTN_Cancel ]);
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_Apply ], SIGNAL(clicked()), SLOT(onApply()));
connect(myButtons[ BTN_Help ], SIGNAL(clicked()), SLOT(onHelp()));
mySourceGrp->button(myApplyToState.contains(theTypes.first()) ?
myApplyToState[ theTypes.first() ] :
- Selection)->setChecked(true);
+ Mesh)->setChecked(true);
}
//=======================================================================
{
if ( !theMesh->_is_nil() ) {
myMesh = theMesh;
- if ( !myFilter[ myTable->GetType() ]->_is_nil() && !myFilter[ myTable->GetType() ]->GetPredicate()->_is_nil() ) {
- SMESH::Predicate_ptr aPred = myFilter[ myTable->GetType() ]->GetPredicate();
- aPred->SetMesh(myMesh);
- }
+ if ( !myFilter[ myTable->GetType() ]->_is_nil())
+ myFilter[ myTable->GetType() ]->SetMesh( theMesh );
}
const bool isEnable = !(myMesh->_is_nil());
myButtons[BTN_OK]->setEnabled(isEnable);
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)
+{
+ myFilter[ type ] = filter;
+}
+
//=======================================================================
// name : SMESHGUI_FilterDlg::insertFilterInViewer
// Purpose : Insert filter in viewer
// filter ids
SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate();
- aPred->SetMesh(myMesh);
QList<int>::const_iterator anIter;
for (anIter = aDialogIds.begin(); anIter != aDialogIds.end(); ++ anIter)
if (aPred->IsSatisfy(*anIter))
// Filter entities
SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate();
- aPred->SetMesh(myMesh);
TColStd_MapIteratorOfMapOfInteger aResIter(aToBeFiltered);
for ( ; aResIter.More(); aResIter.Next())
if (aPred->IsSatisfy(aResIter.Key()))
mySelectionMgr->clearFilters();
int aRow, aCol;
-
+
+ bool isCurrentCell = myTable->CurrentCell(aRow, aCol);
int aCriterionType = myTable->GetCriterionType(aRow);
- if (myTable->CurrentCell(aRow, aCol) &&
+ if ( isCurrentCell &&
(aCriterionType == SMESH::FT_BelongToGeom ||
aCriterionType == SMESH::FT_BelongToPlane ||
aCriterionType == SMESH::FT_BelongToCylinder ||
