-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015 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
// 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.
+// 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
#include "SMESHGUI_FilterLibraryDlg.h"
#include "SMESHGUI_SpinBox.h"
-#include <SMESH_Actor.h>
-#include <SMESH_NumberFilter.hxx>
-#include <SMESH_TypeFilter.hxx>
+#include "SMESH_Actor.h"
+#include "SMESH_NumberFilter.hxx"
+#include "SMESH_TypeFilter.hxx"
+#include "SMESH_LogicalFilter.hxx"
// SALOME GEOM includes
#include <GEOMBase.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
#include <SUIT_MessageBox.h>
+#include <SUIT_OverrideCursor.h>
#include <QtxColorButton.h>
#include <LightApp_Application.h>
#include <LightApp_SelectionMgr.h>
-#include <SalomeApp_Tools.h>
-#include <SalomeApp_Study.h>
-#include <SalomeApp_IntSpinBox.h>
+#include <SalomeApp_Application.h>
#include <SalomeApp_DoubleSpinBox.h>
+#include <SalomeApp_IntSpinBox.h>
+#include <SalomeApp_Study.h>
+#include <SalomeApp_Tools.h>
#include <SALOME_ListIO.hxx>
-#include <SALOME_ListIteratorOfListIO.hxx>
-#include <SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx>
#include <SVTK_ViewWindow.h>
// SALOME KERNEL includes
#include <SALOMEDSClient_Study.hxx>
+#include <Basics_Utils.hxx>
// OCCT includes
#include <StdSelect_TypeOfFace.hxx>
myLibDlg = 0;
}
+ else
+ {
+ QList<int>::const_iterator typeIt = theTypes.begin();
+ for ( ; typeIt != theTypes.end(); ++typeIt ) {
+ if ( !myTables[ *typeIt ] ) {
+ Table* aTable = createTable(mySwitchTableGrp, *typeIt);
+ myTables[ *typeIt ] = aTable;
+ ((QVBoxLayout*)mySwitchTableGrp->layout())->addWidget(myTables[ *typeIt ]);
+ }
+ }
+ }
// Hide buttons of entity types if necessary
const QMap<int, QString>& aSupportedTypes = getSupportedTypes();
{
int aCriterion = GetCriterionType(i, aType);
QString errMsg;
- if (aCriterion == SMESH::FT_GroupColor ) {
+ if (aCriterion == SMESH::FT_GroupColor )
+ {
QtxColorButton* clrBtn = qobject_cast<QtxColorButton*>(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_LyingOnGeom ||
+ aCriterion == SMESH::FT_ConnectedElements )
{
if (aTable->text(i, 2).isEmpty())
errMsg = tr( "ERROR" );
}
- else {
+ else // check correctness of a numeric value
+ {
bool aRes = false;
bool isSignalsBlocked = aTable->signalsBlocked();
aTable->blockSignals(true);
if (!aRes && aTable->isEditable(i, 2))
errMsg = tr( "ERROR" );
- else if (aType == SMESH::EDGE &&
- GetCriterionType(i, aType) == SMESH::FT_MultiConnection &&
- aThreshold == 1)
- errMsg = tr( "MULTIEDGES_ERROR" );
}
if (!errMsg.isEmpty()) {
QtxColorButton* clrBtn = qobject_cast<QtxColorButton*>(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 )
+ 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.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 &&
clrBtn->setColor( qClr );
}
}
- else if (theCriterion.Type == SMESH::FT_ElemGeomType )
+ 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) );
{
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_CoplanarFaces &&
theCriterion.Type != SMESH::FT_FreeBorders &&
theCriterion.Type != SMESH::FT_FreeEdges &&
theCriterion.Type != SMESH::FT_FreeNodes &&
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
ComboItem* anItem = ((ComboItem*)aTable->item(aRow, 0));
int aCriterion = GetCriterionType(aRow);
- bool toEnable = ((((ComboItem*)aTable->item(aRow, 1))->value() == SMESH::FT_EqualTo &&
- aCriterion != SMESH::FT_RangeOfIds &&
- aCriterion != SMESH::FT_FreeEdges &&
- aCriterion != SMESH::FT_FreeFaces &&
- aCriterion != SMESH::FT_BadOrientedVolume &&
- aCriterion != SMESH::FT_BareBorderFace &&
- aCriterion != SMESH::FT_BareBorderVolume &&
- aCriterion != SMESH::FT_OverConstrainedFace &&
- aCriterion != SMESH::FT_OverConstrainedVolume)
- ||
- aCriterion == SMESH::FT_CoplanarFaces);
-
+ 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);
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;
return typeIds;
}
+//=======================================================================
+// name : entityTypes
+// Purpose : returns available entity types of elements
+//=======================================================================
+
+static QList<int> entityTypes( const int theType )
+{
+ QList<int> 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<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 isComboItem = false;
+ bool isIntSpinItem = false;
+ bool isDoubleSpinItem = false;
+ if ( QTableWidgetItem* aTableItem = aTable->item(row, 2) )
+ {
+ int aTableType = aTableItem->type();
+ isComboItem = ( aTableType == ComboItem::Type() );
+ isIntSpinItem = ( aTableType == IntSpinItem::Type() );
+ isDoubleSpinItem = ( aTableType == DoubleSpinItem::Type() );
+ }
+
+ // find out a type of item required by a new criterion and other table features
+ int aCriterionType = GetCriterionType(row);
+ bool anIsDoubleCriterion = false;
+ bool anIsIntCriterion = false;
+ bool anIsComboCriterion = false;
+ // other features:
+ QList<int> comboIDs; // values to show in a combo item
+ int nbCompareSigns = 0; // possible values are 0,1,3
+ bool isThresholdEditable = false; // actual for "simple" item types
+ switch ( aCriterionType )
+ {
+ case SMESH::FT_AspectRatio:
+ case SMESH::FT_AspectRatio3D:
+ case SMESH::FT_Warping:
+ case SMESH::FT_MinimumAngle:
+ case SMESH::FT_Taper:
+ case SMESH::FT_Skew:
+ case SMESH::FT_Area:
+ case SMESH::FT_Volume3D:
+ case SMESH::FT_MaxElementLength2D:
+ case SMESH::FT_MaxElementLength3D:
+ anIsDoubleCriterion = true; break;
+
+ case SMESH::FT_FreeBorders:
+ case SMESH::FT_FreeEdges:
+ case SMESH::FT_FreeNodes:
+ case SMESH::FT_FreeFaces:
+ case SMESH::FT_EqualNodes:
+ case SMESH::FT_EqualEdges:
+ case SMESH::FT_EqualFaces:
+ case SMESH::FT_EqualVolumes: break;
+
+ case SMESH::FT_MultiConnection:
+ case SMESH::FT_MultiConnection2D: anIsIntCriterion = true; nbCompareSigns = 3; break;
+
+ case SMESH::FT_Length:
+ case SMESH::FT_Length2D: anIsDoubleCriterion = true; break;
+
+ case SMESH::FT_BelongToMeshGroup: break;
+
+ case SMESH::FT_BelongToGeom:
+ case SMESH::FT_BelongToPlane:
+ case SMESH::FT_BelongToCylinder:
+ case SMESH::FT_BelongToGenSurface:
+ case SMESH::FT_LyingOnGeom: nbCompareSigns = 0; isThresholdEditable = true; break;
+
+ case SMESH::FT_RangeOfIds: nbCompareSigns = 0; isThresholdEditable = true; break;
+
+ case SMESH::FT_BadOrientedVolume:
+ case SMESH::FT_BareBorderVolume:
+ case SMESH::FT_BareBorderFace:
+ case SMESH::FT_OverConstrainedVolume:
+ case SMESH::FT_OverConstrainedFace:
+ case SMESH::FT_LinearOrQuadratic: break;
+
+ case SMESH::FT_GroupColor: nbCompareSigns = 1; isThresholdEditable = true; break;
+
+ case SMESH::FT_ElemGeomType:
+ comboIDs = geomTypes( aType ); anIsComboCriterion = true; nbCompareSigns = 1; break;
+
+ case SMESH::FT_EntityType:
+ comboIDs = entityTypes( aType ); anIsComboCriterion = true; nbCompareSigns = 1; break;
+
+ case SMESH::FT_CoplanarFaces: isThresholdEditable = true; break;
+
+ case SMESH::FT_BallDiameter: anIsDoubleCriterion = true; break;
+
+ case SMESH::FT_ConnectedElements: isThresholdEditable = true; break;
+
+ case SMESH::FT_LessThan:
+ case SMESH::FT_MoreThan:
+ case SMESH::FT_EqualTo:
+ case SMESH::FT_LogicalNOT:
+ case SMESH::FT_LogicalAND:
+ case SMESH::FT_LogicalOR:
+ case SMESH::FT_Undefined:
+ default: return;
}
-
- 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;
+ // get a precision of a double criterion
int aPrecision = 0;
if ( anIsDoubleCriterion ) {
- const char* aPrecisionType = getPrecision( aCriterionType );
+ 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;
+ // check if the current item type satisfies the criterion
+ bool itemTypeKO =
+ ( aCriterionType == SMESH::FT_GroupColor && !clrBtn) ||
+ ( anIsComboCriterion && !isComboItem ) ||
+ ( anIsIntCriterion && !isIntSpinItem ) ||
+ ( anIsDoubleCriterion && !isDoubleSpinItem );
+
+ if ( !itemTypeKO )
+ {
+ if ( anIsDoubleCriterion )
+ {
+ // if the precision is to be changed we should remove the existing
+ // spin item and create another one with new precision
+ if ( DoubleSpinItem* aDoubleSpinItem = dynamic_cast<DoubleSpinItem*>( aTable->item( row, 2 )))
+ itemTypeKO = ( aDoubleSpinItem->precision() != aPrecision );
+ else
+ itemTypeKO = true;
+ }
+ else if ( anIsComboCriterion )
+ {
+ if ( ComboItem* aComboItem = dynamic_cast<ComboItem*>( aTable->item( row, 2 )))
+ itemTypeKO = ( aComboItem->count() != comboIDs.count() );
+ else
+ itemTypeKO = true;
+ }
+ else if ( !anIsIntCriterion && aCriterionType != SMESH::FT_GroupColor )
+ {
+ itemTypeKO = ( clrBtn || isComboItem || isIntSpinItem || isDoubleSpinItem );
}
}
- if ( (aCriterionType != SMESH::FT_GroupColor && clrBtn) ||
- (aCriterionType != SMESH::FT_ElemGeomType && isComboItem) ||
- (aCriterionType != SMESH::FT_MultiConnection && isIntSpinItem) ||
- (!anIsDoubleCriterion && isDoubleSpinItem) ||
- anIsPrecisionChanged )
+ // update the table row
+
+ bool isSignalsBlocked = aTable->signalsBlocked();
+ aTable->blockSignals( true );
+
+ // update threshold table item
+ if ( itemTypeKO )
{
- bool isSignalsBlocked = aTable->signalsBlocked();
- aTable->blockSignals( true );
aTable->removeCellWidget( row, 2 );
- aTable->setItem( row, 2, new QTableWidgetItem() );
- aTable->blockSignals( isSignalsBlocked );
- }
- if ( (aCriterionType == SMESH::FT_GroupColor && !clrBtn) ||
- (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 )
+
+ if ( aCriterionType == SMESH::FT_GroupColor ) // ---------------------- QtxColorButton
+ {
aTable->setCellWidget( row, 2, new QtxColorButton( aTable ) );
- else if ( aCriterionType == SMESH::FT_ElemGeomType ) {
- QList<int> typeIds = geomTypes( aType );
- QMap<int, QString> typeNames;
- QList<int>::const_iterator anIter = typeIds.begin();
- for ( int i = 0; anIter != typeIds.end(); ++anIter, ++i)
+ }
+ else if ( anIsComboCriterion ) // -------------------------------------------ComboItem
+ {
+ QString msgPrefix
+ ( aCriterionType == SMESH::FT_ElemGeomType ? "GEOM_TYPE_%1" : "ENTITY_TYPE_%1" );
+ QMap<int, QString> names;
+ QList<int>::const_iterator id = comboIDs.begin();
+ for ( ; id != comboIDs.end(); ++id )
{
- QString typeKey = QString( "GEOM_TYPE_%1" ).arg( *anIter );
- typeNames[ *anIter ] = tr( typeKey.toLatin1().data() );
+ QString name = msgPrefix.arg( *id );
+ names[ *id ] = tr( name.toLatin1().data() );
}
- ComboItem* typeBox = new ComboItem( typeNames );
- aTable->setItem( row, 2, typeBox );
+ ComboItem* comboBox = new ComboItem( names );
+ aTable->setItem( row, 2, comboBox );
}
- else if ( aCriterionType == SMESH::FT_MultiConnection ) {
+ else if ( anIsIntCriterion ) // ------------------------------------------ IntSpinItem
+ {
IntSpinItem* intSpin = new IntSpinItem( 0 );
aTable->setItem( row, 2, intSpin );
}
- else if ( anIsDoubleCriterion ) {
+ else if ( anIsDoubleCriterion ) // -------------------------------------DoubleSpinItem
+ {
DoubleSpinItem* dblSpin = new DoubleSpinItem( 0 );
dblSpin->setPrecision( aPrecision );
aTable->setItem( row, 2, dblSpin );
}
- aTable->blockSignals( isSignalsBlocked );
- }
-
- 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 ||
- aCriterionType == SMESH::FT_CoplanarFaces
- )
- {
- bool isSignalsBlocked = aTable->signalsBlocked();
- aTable->blockSignals( true );
-
- 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);
- aTable->blockSignals( isSignalsBlocked );
- }
- else if (aCriterionType == SMESH::FT_RangeOfIds ||
- aCriterionType == SMESH::FT_BelongToGeom ||
- aCriterionType == SMESH::FT_BelongToPlane ||
- aCriterionType == SMESH::FT_BelongToCylinder ||
- aCriterionType == SMESH::FT_BelongToGenSurface ||
- aCriterionType == SMESH::FT_LyingOnGeom)
- {
- QMap<int, QString> aMap;
- aMap[ SMESH::FT_EqualTo ] = tr("EQUAL_TO");
- aCompareItem->setItems(aMap);
- if (!aTable->isEditable(row, 2))
- aTable->setEditable(true, row, 1);
- if (!aTable->isEditable(row, 2))
- aTable->setEditable(true, row, 2);
- }
- else if (aCriterionType == SMESH::FT_GroupColor ||
- aCriterionType == SMESH::FT_ElemGeomType)
- {
- if (!aTable->isEditable(row, 2))
- aTable->setEditable(true, row, 2);
+ else // --------------------------------------------------------------QTableWidgetItem
+ {
+ aTable->setItem( row, 2, new QTableWidgetItem() );
+ }
}
- else
+
+ // set Compare
+ if ( anIsDoubleCriterion )
+ nbCompareSigns = 3;
+ if ( aCompareItem->count() != nbCompareSigns )
{
- if (aCompareItem && aCompareItem->count() != 3)
- {
+ switch ( nbCompareSigns ) {
+ case 0: {
+ aCompareItem->clear();
+ break;
+ }
+ case 1: {
+ QMap<int, QString> 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;
}
-
- if (aTable->item( row, 2 )) {
- QString aText = aTable->text(row, 2);
- bool isOk = false;
- aText.toDouble(&isOk);
- aTable->item( row, 2 )->setText(isOk ? aText : QString(""));
- if (!aTable->isEditable(row, 1))
- aTable->setEditable(true, row, 1);
- if (!aTable->isEditable(row, 2))
- aTable->setEditable(true, row, 2);
}
}
+ aTable->setEditable( nbCompareSigns == 3, row, 1);
+
+ // 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();
{
if( col == 0 )
onCriterionChanged(row, col, -1);
+ else if ( col == 2 )
+ emit ThresholdChanged(row, GetType());
}
//=======================================================================
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");
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_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;
}
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_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;
}
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_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;
}
{
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_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;
}
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;
}
{
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<int, QString> 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;
}
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;
const int theEntityType)
{
Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ];
+
+ bool isSignalsBlocked = aTable->signalsBlocked();
+ aTable->blockSignals(true);
+
aTable->item( theRow, 2 )->setText(theText);
+
+ aTable->blockSignals(isSignalsBlocked);
}
//=======================================================================
: QDialog( SMESH::GetDesktop( theModule ) ),
mySMESHGUI( theModule ),
mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ),
- myInitSourceWgOnApply( true )
+ myInitSourceWgOnApply( true ),
+ myInsertEnabled( true ),
+ myDiffSourcesEnabled( true )
{
if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
mySelector = aViewWindow->GetSelector();
: QDialog( SMESH::GetDesktop( theModule ) ),
mySMESHGUI( theModule ),
mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ),
- myInitSourceWgOnApply( true )
+ myInitSourceWgOnApply( true ),
+ myInsertEnabled( true ),
+ myDiffSourcesEnabled( true )
{
if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
mySelector = aViewWindow->GetSelector();
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);
aLay->addWidget(myButtons[ BTN_Help ]);
connect(myButtons[ BTN_OK ], SIGNAL(clicked()), SLOT(onOk()));
- 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()));
// 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)
{
QList<int> 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 QList<int>& theTypes)
+void SMESHGUI_FilterDlg::Init (const QList<int>& theTypes, const bool setInViewer)
{
mySourceWg = 0;
myTypes = theTypes;
myMesh = SMESH::SMESH_Mesh::_nil();
+ myGroup = SMESH::SMESH_GroupOnFilter::_nil();
myIObjects.Clear();
myIsSelectionChanged = false;
+ myToRestoreSelMode = false;
myTable->Init(theTypes);
{
int aType = theTypes.first();
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"));
mySMESHGUI->SetActiveDialogBox((QDialog*)this);
connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(onDeactivate()));
- connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(onClose()));
+ connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject()));
updateMainButtons();
updateSelection();
if (myInsertState.contains(theTypes.first()))
mySetInViewer->setChecked(myInsertState[ theTypes.first() ]);
else
- mySetInViewer->setChecked(true);
+ mySetInViewer->setChecked(setInViewer);
mySourceGrp->button(myApplyToState.contains(theTypes.first()) ?
myApplyToState[ theTypes.first() ] :
{
if (onApply())
{
+ restoreSelMode();
mySelectionMgr->clearFilters();
disconnect(mySMESHGUI, 0, this, 0);
disconnect(mySelectionMgr, 0, this, 0);
}
//=======================================================================
-// 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)
{
disconnect(mySMESHGUI, 0, this, 0);
disconnect(mySelectionMgr, 0, this, 0);
mySMESHGUI->ResetState();
- reject();
- return;
+ QDialog::reject();
}
//=================================================================================
setEnabled(true);
}
-//=======================================================================
-// name : closeEvent()
-// Purpose :
-//=======================================================================
-void SMESHGUI_FilterDlg::closeEvent (QCloseEvent*)
-{
- onClose();
-}
-
//=======================================================================
// name : SMESHGUI_FilterDlg::getIdsFromWg
// Purpose : Retrieve list of ids from given widget
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;
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(aList[ 0 ]->GetObject());
+ 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;
//=======================================================================
// 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,
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::SetMesh
// Purpose : Set mesh
myButtons[BTN_Apply]->setEnabled(isEnable);
}
+//=======================================================================
+// name : SMESHGUI_FilterDlg::SetGroup
+// Purpose : Set a group being edited
+//=======================================================================
+void SMESHGUI_FilterDlg::SetGroup(SMESH::SMESH_GroupOnFilter_var group)
+{
+ myGroup = group;
+}
+
//=======================================================================
// name : SMESHGUI_FilterDlg::SetSelection
// Purpose : Get filtered ids
if (!isValid())
return false;
+ SUIT_OverrideCursor wc;
try {
int aCurrType = myTable->GetType();
insertFilterInViewer();
if (!myFilter[ aCurrType ]->GetPredicate()->_is_nil()) {
- QList<int> aResultIds;
- filterSource(aCurrType, aResultIds);
- // select in viewer
- selectInViewer(aCurrType, aResultIds);
+ //
+ bool toFilter = (( SMESH::FindActorByObject( myMesh )) ||
+ ( myInitSourceWgOnApply && mySourceWg ) ||
+ ( mySourceGrp->checkedId() == Dialog && mySourceWg ));
+ if ( toFilter ) {
+ QList<int> aResultIds;
+ filterSource(aCurrType, aResultIds);
+ // select in viewer
+ selectInViewer(aCurrType, aResultIds);
+ }
}
-
myInsertState[ aCurrType ] = mySetInViewer->isChecked();
myApplyToState[ aCurrType ] = mySourceGrp->checkedId();
}
catch(const SALOME::SALOME_Exception& S_ex)
{
SalomeApp_Tools::QtCatchCorbaException(S_ex);
+ return false;
}
catch(...)
{
+ return false;
}
return true;
aCriteria[ i ] = aCriterion;
}
+ if ( !myFilter[ theType ]->_is_nil() )
+ myFilter[ theType ]->UnRegister();
myFilter[ theType ] = aFilterMgr->CreateFilter();
myFilter[ theType ]->SetCriteria(aCriteria.inout());
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
SMESH::ElementType anEntType = (SMESH::ElementType)myTable->GetType();
if (myFilter[ myTable->GetType() ]->_is_nil() ||
- myFilter[ myTable->GetType() ]->GetPredicate()->_is_nil() ||
- !mySetInViewer->isChecked()) {
+ myFilter[ myTable->GetType() ]->GetPredicate()->_is_nil() ||
+ !mySetInViewer->isChecked() ||
+ !myInsertEnabled )
+ {
SMESH::RemoveFilter(getFilterId(anEntType), aSelector);
}
else {
int aSourceId = mySourceGrp->checkedId();
- if (aSourceId == Mesh)
+ if (aSourceId == Mesh || !myDiffSourcesEnabled )
{
if (myMesh->_is_nil())
return;
if ( aViewWindow && aViewWindow->SelectionMode()!=aSelMode) {
mySelectionMgr->clearSelected();
mySelectionMgr->clearFilters();
- if (aSelMode == NodeSelection)
- SMESH::SetPointRepresentation(true);
+ SMESH::SetPointRepresentation( aSelMode == NodeSelection );
aViewWindow->SetSelectionMode(aSelMode);
}
//=======================================================================
void SMESHGUI_FilterDlg::onSelectionDone()
{
- int aRow, aCol;
const SALOME_ListIO& aList = mySelector->StoredIObjects();
-
- if ( myMesh->_is_nil() && aList.Extent()>0 ) {
+ if ( myMesh->_is_nil() && aList.Extent()>0 )
+ {
myMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(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;
+ const int type = myTable->GetCriterionType(aRow);
QList<int> types;
- types << SMESH::FT_BelongToGeom << SMESH::FT_BelongToPlane
- << SMESH::FT_BelongToCylinder << SMESH::FT_BelongToGenSurface
- << SMESH::FT_LyingOnGeom << SMESH::FT_CoplanarFaces;
- if (aList.Extent() != 1 || !myTable->CurrentCell(aRow, aCol) ||
- !types.contains(myTable->GetCriterionType(aRow)))
+ 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;
- if ( myTable->GetCriterionType(aRow) == SMESH::FT_CoplanarFaces )
+ Handle(SALOME_InteractiveObject) anIO = aList.First();
+ switch ( type )
{
- QString aString;
- int nbElems = SMESH::GetNameOfSelectedElements(mySelector,//myViewWindow->GetSelector(),
- aList.First(), aString);
- if (nbElems == 1)
- myTable->SetThreshold(aRow, aString);
- }
- else
- {
- Handle(SALOME_InteractiveObject) anIO = aList.First();
- GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface<GEOM::GEOM_Object>(anIO);
- if (!anObj->_is_nil())
+ 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<GEOM::GEOM_Object>(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<SMESH::SMESH_GroupBase>(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
{
- myTable->SetThreshold(aRow, GEOMBase::GetName(anObj));
- //myTable->SetID( aRow, GEOMBase::GetIORFromObject(anObj));
- myTable->SetID(aRow, anIO->getEntry());
+ GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface<GEOM::GEOM_Object>(anIO);
+ if (!anObj->_is_nil())
+ {
+ myTable->SetThreshold(aRow, GEOMBase::GetName(anObj));
+ myTable->SetID (aRow, anIO->getEntry());
+ }
}
}
}
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
if( !aStudy )
return;
+ restoreSelMode();
mySelectionMgr->clearFilters();
myIsSelectionChanged = true;
}
+ 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<SUIT_SelectionFilter*> fList;
+ fList.push_back( new SMESH_NumberFilter( "GEOM", TopAbs_SHAPE, 1, TopAbs_VERTEX ));
+ fList.push_back( new SMESH_TypeFilter( SMESH::IDSOURCE ));
+ mySelectionMgr->installFilter
+ ( new SMESH_LogicalFilter( fList, SMESH_LogicalFilter::LO_OR,
+ !mySelectionMgr->autoDeleteFilter() ));
+
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ {
+ mySelModeToRestore = aViewWindow->SelectionMode();
+ aViewWindow->SetSelectionMode( NodeSelection );
+ myToRestoreSelMode = ( mySelModeToRestore != NodeSelection );
+ if ( myToRestoreSelMode )
+ SMESH::SetPointRepresentation( true );
+ }
+ }
else
{
+ mySelector->SetSelectionMode( getSelMode( myTable->GetType() ));
+
if (myIsSelectionChanged) {
// mySelectionMgr->installFilter( new GEOM_TypeFilter( aStudy, -1 ) ); // This filter deactivates selection
// Impossible to select any object in the OB on the second opening of FilterDlg
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;
+ }
+}
