X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_FilterDlg.cxx;h=4211d08bffaa52994ee96cba3463069744b36e4c;hp=f1097018ab771ebd18e960b3c5abf3ebd798b054;hb=4c65637b3ba0be986e1ce6e952689b2686475b2f;hpb=88b3dbe23b236bd1746405155ae33a76aaf59ecd diff --git a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx index f1097018a..4211d08bf 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-2014 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,6 +51,7 @@ #include #include #include +#include #include #include @@ -67,6 +69,7 @@ // SALOME KERNEL includes #include +#include // OCCT includes #include @@ -1126,7 +1129,8 @@ 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" ); @@ -1137,13 +1141,16 @@ bool SMESHGUI_FilterTable::IsValid (const bool theMess, const int theEntityType) 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); @@ -1152,10 +1159,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()) { @@ -1245,16 +1248,42 @@ 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_BelongToGeom && aCriterionType != SMESH::FT_BelongToPlane && @@ -1324,7 +1353,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) ); @@ -1333,13 +1363,32 @@ 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_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 && @@ -1517,7 +1566,8 @@ void SMESHGUI_FilterTable::updateAdditionalWidget() aCriterion != SMESH::FT_OverConstrainedFace && aCriterion != SMESH::FT_OverConstrainedVolume) || - aCriterion == SMESH::FT_CoplanarFaces); + aCriterion == SMESH::FT_CoplanarFaces || + aCriterion == SMESH::FT_EqualNodes); if (!myAddWidgets.contains(anItem)) { @@ -1556,6 +1606,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; @@ -1651,180 +1702,283 @@ 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_BelongToGeom: + case SMESH::FT_BelongToPlane: + case SMESH::FT_BelongToCylinder: + case SMESH::FT_BelongToGenSurface: + case SMESH::FT_LyingOnGeom: nbCompareSigns = 1; isThresholdEditable = true; break; + + case SMESH::FT_RangeOfIds: nbCompareSigns = 1; 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 ); - } - - // set Compare and enable/desable Threshold - 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: { aCompareItem->setItems(getCompare()); + 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(); @@ -1840,6 +1994,8 @@ void SMESHGUI_FilterTable::onCriterionChanged (int row, int col) { if( col == 0 ) onCriterionChanged(row, col, -1); + else if ( col == 2 ) + emit ThresholdChanged(row, GetType()); } //======================================================================= @@ -2013,6 +2169,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; } @@ -2034,6 +2191,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; } @@ -2066,6 +2225,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; } @@ -2087,6 +2248,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; } @@ -2101,6 +2264,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; } @@ -2116,6 +2280,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; } @@ -2130,6 +2295,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; } @@ -2144,6 +2310,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria (const int theType) 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; @@ -2413,7 +2580,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); } //======================================================================= @@ -2692,6 +2865,7 @@ void SMESHGUI_FilterDlg::Init (const QList& theTypes, const bool setInViewe myMesh = SMESH::SMESH_Mesh::_nil(); myIObjects.Clear(); myIsSelectionChanged = false; + myToRestoreSelMode = false; myTable->Init(theTypes); @@ -2758,6 +2932,7 @@ void SMESHGUI_FilterDlg::onOk() { if (onApply()) { + restoreSelMode(); mySelectionMgr->clearFilters(); disconnect(mySMESHGUI, 0, this, 0); disconnect(mySelectionMgr, 0, this, 0); @@ -2773,6 +2948,7 @@ void SMESHGUI_FilterDlg::onOk() //======================================================================= void SMESHGUI_FilterDlg::reject() { + restoreSelMode(); // Restore previously selected object if (mySelectionMgr) { @@ -3092,6 +3268,7 @@ bool SMESHGUI_FilterDlg::onApply() if (!isValid()) return false; + SUIT_OverrideCursor wc; try { int aCurrType = myTable->GetType(); @@ -3114,9 +3291,11 @@ bool SMESHGUI_FilterDlg::onApply() catch(const SALOME::SALOME_Exception& S_ex) { SalomeApp_Tools::QtCatchCorbaException(S_ex); + return false; } catch(...) { + return false; } return true; @@ -3150,6 +3329,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()); @@ -3183,9 +3364,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 @@ -3345,8 +3546,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); } @@ -3416,42 +3616,64 @@ 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))) + << SMESH::FT_LyingOnGeom << SMESH::FT_CoplanarFaces + << SMESH::FT_ConnectedElements; + 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; + } + 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()); + } } } } @@ -3466,6 +3688,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 @@ -3491,6 +3727,7 @@ void SMESHGUI_FilterDlg::updateSelection() if( !aStudy ) return; + restoreSelMode(); mySelectionMgr->clearFilters(); @@ -3520,6 +3757,24 @@ void SMESHGUI_FilterDlg::updateSelection() myIsSelectionChanged = true; } + 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() )); @@ -3546,3 +3801,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; + } +}