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=d29ae2c82a064b9d19c6b322ac2adb369bfc9851;hb=c4cacfb5c15254953d6a1ce60a2196e099c91a9a;hpb=f5016d85b7b4b88623723027a1585c6414c4dc66 diff --git a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx index d29ae2c82..97f1df847 100755 --- a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx +++ b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx @@ -1,4 +1,4 @@ -// 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 @@ -6,7 +6,7 @@ // 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 @@ -36,9 +36,10 @@ #include "SMESHGUI_FilterLibraryDlg.h" #include "SMESHGUI_SpinBox.h" -#include -#include -#include +#include "SMESH_Actor.h" +#include "SMESH_NumberFilter.hxx" +#include "SMESH_TypeFilter.hxx" +#include "SMESH_LogicalFilter.hxx" // SALOME GEOM includes #include @@ -50,23 +51,24 @@ #include #include #include +#include #include #include #include -#include -#include -#include +#include #include +#include +#include +#include #include -#include -#include #include // SALOME KERNEL includes #include +#include // OCCT includes #include @@ -1002,6 +1004,18 @@ void SMESHGUI_FilterTable::Init (const QList& theTypes) 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(); @@ -1115,24 +1129,29 @@ bool SMESHGUI_FilterTable::IsValid (const bool theMess, const int theEntityType) { int aCriterion = GetCriterionType(i, aType); QString errMsg; - if (aCriterion == SMESH::FT_GroupColor ) { + 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_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); @@ -1141,10 +1160,6 @@ bool SMESHGUI_FilterTable::IsValid (const bool theMess, const int theEntityType) 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()) { @@ -1234,17 +1249,44 @@ void SMESHGUI_FilterTable::GetCriterion (const int theRow, 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 ) + 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 && @@ -1313,7 +1355,8 @@ void SMESHGUI_FilterTable::SetCriterion (const int theRow, 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) ); @@ -1322,13 +1365,33 @@ void SMESHGUI_FilterTable::SetCriterion (const int theRow, { 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 && @@ -1340,6 +1403,7 @@ void SMESHGUI_FilterTable::SetCriterion (const int theRow, 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 @@ -1496,18 +1560,29 @@ void SMESHGUI_FilterTable::updateAdditionalWidget() 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); @@ -1545,6 +1620,7 @@ const char* SMESHGUI_FilterTable::getPrecision( const int aType ) 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; @@ -1640,179 +1716,288 @@ static QList geomTypes( const int theType ) 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)); - 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 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( 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( 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 ); } } - 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 typeIds = geomTypes( aType ); - QMap typeNames; - QList::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 names; + QList::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 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 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(); @@ -1828,6 +2013,8 @@ void SMESHGUI_FilterTable::onCriterionChanged (int row, int col) { if( col == 0 ) onCriterionChanged(row, col, -1); + else if ( col == 2 ) + emit ThresholdChanged(row, GetType()); } //======================================================================= @@ -1970,6 +2157,7 @@ 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"); @@ -1992,6 +2180,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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"); @@ -2000,6 +2189,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; } @@ -2012,6 +2202,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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"); @@ -2021,6 +2212,8 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; } @@ -2038,6 +2231,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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"); @@ -2053,6 +2247,8 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; } @@ -2063,6 +2259,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) { 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"); @@ -2074,6 +2271,8 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; } @@ -2083,11 +2282,13 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; } @@ -2098,11 +2299,29 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) { 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; } @@ -2112,11 +2331,13 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; @@ -2386,7 +2607,13 @@ void SMESHGUI_FilterTable::SetThreshold (const int theRow, 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); } //======================================================================= @@ -2454,7 +2681,9 @@ SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule, : 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(); @@ -2471,7 +2700,9 @@ SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule, : 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(); @@ -2530,6 +2761,7 @@ QWidget* SMESHGUI_FilterDlg::createMainFrame (QWidget* theParent) 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); @@ -2626,7 +2858,7 @@ QWidget* SMESHGUI_FilterDlg::createButtonFrame (QWidget* theParent) 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())); @@ -2660,11 +2892,18 @@ void SMESHGUI_FilterDlg::Init (const int type, const bool setInViewer) //======================================================================= 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); @@ -2673,6 +2912,8 @@ void SMESHGUI_FilterDlg::Init (const QList& theTypes, const bool setInViewe { 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")); @@ -2689,7 +2930,9 @@ void SMESHGUI_FilterDlg::Init (const QList& theTypes, const bool setInViewe mySMESHGUI->SetActiveDialogBox((QDialog*)this); connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(onDeactivate())); - connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(onClose())); + connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject())); + connect(mySMESHGUI, SIGNAL(SignalActivatedViewManager()), SLOT(onOpenView())); + connect(mySMESHGUI, SIGNAL(SignalCloseView()), SLOT(onCloseView())); updateMainButtons(); updateSelection(); @@ -2729,6 +2972,7 @@ void SMESHGUI_FilterDlg::onOk() { if (onApply()) { + restoreSelMode(); mySelectionMgr->clearFilters(); disconnect(mySMESHGUI, 0, this, 0); disconnect(mySelectionMgr, 0, this, 0); @@ -2739,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) { @@ -2770,8 +3015,30 @@ 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; } //================================================================================= @@ -2819,15 +3086,6 @@ 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 @@ -2879,6 +3137,8 @@ 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; @@ -2944,8 +3204,7 @@ bool SMESHGUI_FilterDlg::isValid() const 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; @@ -3018,6 +3277,21 @@ 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 @@ -3034,6 +3308,15 @@ void SMESHGUI_FilterDlg::SetMesh (SMESH::SMESH_Mesh_var theMesh) 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 @@ -3071,6 +3354,7 @@ bool SMESHGUI_FilterDlg::onApply() if (!isValid()) return false; + SUIT_OverrideCursor wc; try { int aCurrType = myTable->GetType(); @@ -3080,22 +3364,32 @@ bool SMESHGUI_FilterDlg::onApply() insertFilterInViewer(); if (!myFilter[ aCurrType ]->GetPredicate()->_is_nil()) { - QList aResultIds; - filterSource(aCurrType, aResultIds); - // select in viewer - 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->checkedId(); } catch(const SALOME::SALOME_Exception& S_ex) { SalomeApp_Tools::QtCatchCorbaException(S_ex); + return false; } catch(...) { + return false; } return true; @@ -3129,6 +3423,8 @@ 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()); @@ -3162,9 +3458,29 @@ SMESH::Filter_var SMESHGUI_FilterDlg::GetFilter() const 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 @@ -3175,8 +3491,10 @@ void SMESHGUI_FilterDlg::insertFilterInViewer() 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 { @@ -3201,7 +3519,7 @@ void SMESHGUI_FilterDlg::filterSource (const int theType, int aSourceId = mySourceGrp->checkedId(); - if (aSourceId == Mesh) + if (aSourceId == Mesh || !myDiffSourcesEnabled ) { if (myMesh->_is_nil()) return; @@ -3233,9 +3551,6 @@ void SMESHGUI_FilterDlg::filterSource (const int theType, if (aPred->IsSatisfy(*anIter)) theResIds.append(*anIter); } - // set ids to the dialog - if (myInitSourceWgOnApply || aSourceId == Dialog) - setIdsToWg(mySourceWg, theResIds); } //======================================================================= @@ -3324,8 +3639,7 @@ void SMESHGUI_FilterDlg::selectInViewer (const int theType, const QList& th if ( aViewWindow && aViewWindow->SelectionMode()!=aSelMode) { mySelectionMgr->clearSelected(); mySelectionMgr->clearFilters(); - if (aSelMode == NodeSelection) - SMESH::SetPointRepresentation(true); + SMESH::SetPointRepresentation( aSelMode == NodeSelection ); aViewWindow->SetSelectionMode(aSelMode); } @@ -3395,42 +3709,82 @@ 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 ) { + 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; + 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; - 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 ) - { - 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(); + switch ( type ) { - Handle(SALOME_InteractiveObject) anIO = aList.First(); - GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface(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(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 { - myTable->SetThreshold(aRow, GEOMBase::GetName(anObj)); - //myTable->SetID( aRow, GEOMBase::GetIORFromObject(anObj)); - myTable->SetID(aRow, anIO->getEntry()); + GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface(anIO); + if (!anObj->_is_nil()) + { + myTable->SetThreshold(aRow, GEOMBase::GetName(anObj)); + myTable->SetID (aRow, anIO->getEntry()); + } } } } @@ -3445,6 +3799,20 @@ 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 @@ -3470,6 +3838,7 @@ void SMESHGUI_FilterDlg::updateSelection() if( !aStudy ) return; + restoreSelMode(); mySelectionMgr->clearFilters(); @@ -3499,6 +3868,41 @@ void SMESHGUI_FilterDlg::updateSelection() 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 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() )); @@ -3525,3 +3929,22 @@ void SMESHGUI_FilterDlg::keyPressEvent( QKeyEvent* e ) 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; + } +}