-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#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>
// SALOME KERNEL includes
#include <SALOMEDSClient_Study.hxx>
#include <Basics_Utils.hxx>
+#include <smIdType.hxx>
// OCCT includes
#include <StdSelect_TypeOfFace.hxx>
void SMESHGUI_FilterTable::ComboDelegate::updateEditorGeometry( QWidget* editor,
const QStyleOptionViewItem& option,
- const QModelIndex& index ) const
+ const QModelIndex& /*index*/ ) const
{
editor->setGeometry( option.rect );
}
//=======================================================================
// name : SMESHGUI_FilterTable::Table::isEditable
-// Purpose : Verify wheter cell is editable
+// Purpose : Verify whether cell is editable
//=======================================================================
bool SMESHGUI_FilterTable::Table::isEditable (int row, int col) const
{
/*
Class : SMESHGUI_FilterTable
- Description : Frame containig
+ Description : Frame containing
- Button group for switching entity type
- Table for displaying filter criterions
- Buttons for editing table and filter libraries
QWidget* parent,
const int type )
: QWidget( parent ),
- myIsLocked( false ),
- mySMESHGUI( theModule )
+ mySMESHGUI( theModule ),
+ myIsLocked( false )
{
myEntityType = -1;
QWidget* parent,
const QList<int>& types )
: QWidget( parent ),
- myIsLocked( false ),
- mySMESHGUI( theModule )
+ mySMESHGUI( theModule ),
+ myIsLocked( false )
{
myEntityType = -1;
Init(types);
Table* aTable = createTable(mySwitchTableGrp, *typeIt);
myTables[ *typeIt ] = aTable;
((QVBoxLayout*)mySwitchTableGrp->layout())->addWidget(myTables[ *typeIt ]);
+ myEntityType = -1;
}
}
}
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 ||
bool aRes = false;
bool isSignalsBlocked = aTable->signalsBlocked();
aTable->blockSignals(true);
- double aThreshold = (int)aTable->text(i, 2).toDouble(&aRes);
+ /*double aThreshold =*/ aTable->text(i, 2).toDouble( &aRes );
aTable->blockSignals(isSignalsBlocked);
if (!aRes && aTable->isEditable(i, 2))
}
}
else if ( aCriterionType != SMESH::FT_RangeOfIds &&
+ aCriterionType != SMESH::FT_BelongToMeshGroup &&
aCriterionType != SMESH::FT_BelongToGeom &&
aCriterionType != SMESH::FT_BelongToPlane &&
aCriterionType != SMESH::FT_BelongToCylinder &&
{
if ( strlen( theCriterion.ThresholdID ) > 0 ) // shape ID -> name
{
- _PTR(SObject) sobj =
- SMESH::GetActiveStudyDocument()->FindObjectID( theCriterion.ThresholdID.in() );
+ _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( theCriterion.ThresholdID.in() );
if ( !sobj )
aTable->item( theRow, 2 )->setText( QString( theCriterion.ThresholdID ) );
else
}
}
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_OverConstrainedVolume &&
theCriterion.Type != SMESH::FT_LinearOrQuadratic)
{
+ // Numeric criterion
aTable->item( theRow, 2 )->setText(QString("%1").arg(theCriterion.Threshold, 0, 'g', 15));
}
else
//=======================================================================
// name : SMESHGUI_FilterTable::updateAdditionalWidget
-// Purpose : Enable/Disable widget with additonal parameters
+// Purpose : Enable/Disable widget with additional parameters
//=======================================================================
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_Warping3D ||
+ aCriterion == SMESH::FT_MinimumAngle ||
+ aCriterion == SMESH::FT_Taper ||
+ aCriterion == SMESH::FT_Skew ||
+ aCriterion == SMESH::FT_Area ||
+ aCriterion == SMESH::FT_Volume3D ||
+ aCriterion == SMESH::FT_ScaledJacobian ||
+ aCriterion == SMESH::FT_MaxElementLength2D ||
+ aCriterion == SMESH::FT_MaxElementLength3D ||
+ aCriterion == SMESH::FT_Length ||
+ aCriterion == SMESH::FT_Length2D ||
+ aCriterion == SMESH::FT_Length3D ||
+ aCriterion == SMESH::FT_Deflection2D ||
+ 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_Taper:
retval = "parametric_precision"; break;
case SMESH::FT_Warping:
+ case SMESH::FT_Warping3D:
case SMESH::FT_MinimumAngle:
case SMESH::FT_Skew:
case SMESH::FT_CoplanarFaces:
retval = "len_tol_precision"; break;
case SMESH::FT_Length:
case SMESH::FT_Length2D:
+ case SMESH::FT_Length3D:
+ case SMESH::FT_Deflection2D:
case SMESH::FT_MaxElementLength2D:
case SMESH::FT_MaxElementLength3D:
case SMESH::FT_BallDiameter:
{
case SMESH::NODE:
typeIds.append( SMDSEntity_Node );
+ break;
case SMESH::EDGE:
typeIds.append( SMDSEntity_Edge );
typeIds.append( SMDSEntity_Quad_Edge );
typeIds.append( SMDSEntity_Quad_Quadrangle );
typeIds.append( SMDSEntity_BiQuad_Quadrangle );
typeIds.append( SMDSEntity_Polygon );
- //typeIds.append( SMDSEntity_Quad_Polygon );
+ typeIds.append( SMDSEntity_Quad_Polygon );
break;
case SMESH::VOLUME:
typeIds.append( SMDSEntity_Tetra );
typeIds.append( SMDSEntity_TriQuad_Hexa );
typeIds.append( SMDSEntity_Penta );
typeIds.append( SMDSEntity_Quad_Penta );
+ typeIds.append( SMDSEntity_BiQuad_Penta );
typeIds.append( SMDSEntity_Hexagonal_Prism );
typeIds.append( SMDSEntity_Polyhedra );
//typeIds.append( SMDSEntity_Quad_Polyhedra );
// Purpose : Provides reaction on change of criterion
//=======================================================================
-void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int entityType)
+void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int /*col*/, const int entityType)
{
int aType = entityType == -1 ? GetType() : entityType;
Table* aTable = myTables[ aType ];
}
// find out a type of item required by a new criterion and other table features
- int aCriterionType = GetCriterionType(row);
+ 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
+ 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_Warping3D:
case SMESH::FT_MinimumAngle:
case SMESH::FT_Taper:
case SMESH::FT_Skew:
case SMESH::FT_Area:
case SMESH::FT_Volume3D:
+ case SMESH::FT_ScaledJacobian:
case SMESH::FT_MaxElementLength2D:
- case SMESH::FT_MaxElementLength3D:
- anIsDoubleCriterion = true; break;
+ case SMESH::FT_MaxElementLength3D: anIsDoubleCriterion = true; break;
case SMESH::FT_FreeBorders:
case SMESH::FT_FreeEdges:
case SMESH::FT_EqualFaces:
case SMESH::FT_EqualVolumes: break;
+ case SMESH::FT_NodeConnectivityNumber:
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_Length2D:
+ case SMESH::FT_Length3D:
+ case SMESH::FT_Deflection2D: 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 = 1; isThresholdEditable = true; break;
+ case SMESH::FT_LyingOnGeom: nbCompareSigns = 0; isThresholdEditable = true; break;
- case SMESH::FT_RangeOfIds: nbCompareSigns = 1; isThresholdEditable = true; break;
+ case SMESH::FT_RangeOfIds: nbCompareSigns = 0; isThresholdEditable = true; break;
case SMESH::FT_BadOrientedVolume:
case SMESH::FT_BareBorderVolume:
}
myIsLocked = false;
- // IPAL19372 - to prevent calling onCriterionChaged() slot before completion of setItem()
+ // IPAL19372 - to prevent calling onCriterionChanged() slot before completion of setItem()
bool isSignalsBlocked = theTable->signalsBlocked();
theTable->blockSignals( true );
//=======================================================================
// name : SMESHGUI_FilterTable::getCompareItem
-// Purpose : Get combo table item for operation of comparision
+// Purpose : Get combo table item for operation of comparison
//=======================================================================
QTableWidgetItem* SMESHGUI_FilterTable::getCompareItem () const
{
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_GroupColor ] = tr("GROUP_COLOR");
aCriteria[ SMESH::FT_EqualNodes ] = tr("EQUAL_NODE");
aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS");
+ aCriteria[ SMESH::FT_NodeConnectivityNumber ] = tr("NODE_CONN_NUMBER");
}
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_MaxElementLength2D ] = tr("MAX_ELEMENT_LENGTH_2D");
aCriteria[ SMESH::FT_FreeEdges ] = tr("FREE_EDGES");
aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS");
+ aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP");
aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM");
aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE");
aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER");
aCriteria[ SMESH::FT_BelongToGenSurface ] = tr("BELONG_TO_GENSURFACE");
aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM");
aCriteria[ SMESH::FT_Length2D ] = tr("LENGTH2D");
+ aCriteria[ SMESH::FT_Deflection2D ] = tr("DEFLECTION2D");
aCriteria[ SMESH::FT_MultiConnection2D ] = tr("MULTI2D_BORDERS");
aCriteria[ SMESH::FT_FreeFaces ] = tr("FREE_FACES");
aCriteria[ SMESH::FT_BareBorderFace ] = tr("BARE_BORDER_FACE");
if (aCriteria.isEmpty())
{
aCriteria[ SMESH::FT_AspectRatio3D ] = tr("ASPECT_RATIO_3D");
+ aCriteria[ SMESH::FT_Warping3D ] = tr("WARPING_3D");
aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS");
+ aCriteria[ SMESH::FT_BelongToMeshGroup ] = tr("BELONG_TO_MESH_GROUP");
aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM");
aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM");
aCriteria[ SMESH::FT_BadOrientedVolume ] = tr("BAD_ORIENTED_VOLUME");
aCriteria[ SMESH::FT_BareBorderVolume ] = tr("BARE_BORDER_VOLUME");
aCriteria[ SMESH::FT_OverConstrainedVolume] = tr("OVER_CONSTRAINED_VOLUME");
+ aCriteria[ SMESH::FT_Length3D ] = tr("LENGTH3D");
aCriteria[ SMESH::FT_Volume3D ] = tr("VOLUME_3D");
aCriteria[ SMESH::FT_MaxElementLength3D ] = tr("MAX_ELEMENT_LENGTH_3D");
aCriteria[ SMESH::FT_LinearOrQuadratic ] = tr("LINEAR");
aCriteria[ SMESH::FT_EqualVolumes ] = tr("EQUAL_VOLUME");
aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE");
aCriteria[ SMESH::FT_ConnectedElements ] = tr("CONNECTED_ELEMS");
+ aCriteria[ SMESH::FT_ScaledJacobian ] = tr("SCALED_JACOBIAN");
}
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_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");
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");
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");
// Purpose : Create table
//=======================================================================
SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* theParent,
- const int theType)
+ const int /*theType*/)
{
// create table
Table* aTable= new Table(0, 6, theParent);
aDlgLay->setStretchFactor(myMainFrame, 1);
- myHelpFileName = "selection_filter_library_page.html";
+ myHelpFileName = "selection_filter_library.html";
Init(myTypes);
}
//=======================================================================
void SMESHGUI_FilterDlg::Init (const QList<int>& 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;
connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(onDeactivate()));
connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(reject()));
+ connect(mySMESHGUI, SIGNAL(SignalActivatedViewManager()), SLOT(onOpenView()));
+ connect(mySMESHGUI, SIGNAL(SignalCloseView()), SLOT(onCloseView()));
updateMainButtons();
updateSelection();
SALOME_ListIO aList;
mySelectionMgr->clearFilters();
mySelectionMgr->clearSelected();
- SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter (myIObjects);
+ SALOME_DataMapIteratorOfIOMapOfVtk anIter (myIObjects);
for ( ; anIter.More(); anIter.Next())
{
aList.Append(anIter.Key());
- TColStd_MapOfInteger aResMap;
- const TColStd_IndexedMapOfInteger& anIndMap = anIter.Value();
+ SVTK_TVtkIDsMap aResMap;
+ const SVTK_TIndexedMapOfVtkId& anIndMap = anIter.Value();
for (int i = 1, n = anIndMap.Extent(); i <= n; i++)
aResMap.Add(anIndMap(i));
QDialog::reject();
}
+//=================================================================================
+// function : onOpenView()
+// purpose :
+//=================================================================================
+void SMESHGUI_FilterDlg::onOpenView()
+{
+ if ( mySelector ) {
+ SMESH::SetPointRepresentation(false);
+ }
+ else {
+ mySelector = SMESH::GetViewWindow( mySMESHGUI )->GetSelector();
+ }
+}
+
+//=================================================================================
+// function : onCloseView()
+// purpose :
+//=================================================================================
+void SMESHGUI_FilterDlg::onCloseView()
+{
+ mySelector = 0;
+}
+
//=================================================================================
// function : onHelp()
// purpose :
//=======================================================================
// name : SMESHGUI_FilterDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
//=======================================================================
void SMESHGUI_FilterDlg::onDeactivate()
{
QString aName;
myTable->GetThreshold(i, aName);
- std::vector<_PTR(SObject)> aList =
- SMESH::GetActiveStudyDocument()->FindObjectByName(aName.toLatin1().constData(), "GEOM");
+ std::vector<_PTR(SObject)> aList = SMESH::getStudy()->FindObjectByName(aName.toUtf8().constData(), "GEOM");
+ if (aList.size() == 0)
+ aList = SMESH::getStudy()->FindObjectByName(aName.toUtf8().constData(), "SHAPERSTUDY");
if (aList.size() == 0) {
SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
tr("BAD_SHAPE_NAME").arg(aName));
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;
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
const SALOME_ListIO& anObjs = mySelector->StoredIObjects();
SALOME_ListIteratorOfListIO anIter (anObjs);
for ( ; anIter.More(); anIter.Next()) {
- TColStd_IndexedMapOfInteger aMap;
+ SVTK_TIndexedMapOfVtkId aMap;
mySelector->GetIndex(anIter.Value(), aMap);
myIObjects.Bind(anIter.Value(), aMap);
}
insertFilterInViewer();
if (!myFilter[ aCurrType ]->GetPredicate()->_is_nil()) {
- QList<int> aResultIds;
- filterSource(aCurrType, aResultIds);
- // select in viewer
- selectInViewer(aCurrType, aResultIds);
+ //
+ bool toFilter = (( getActor() ) ||
+ ( myInitSourceWgOnApply && mySourceWg ) ||
+ ( mySourceGrp->checkedId() == Dialog && mySourceWg ));
+ if ( toFilter ) {
+ QList<int> 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();
}
if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
aPrecision = mgr->integerValue( "SMESH", "controls_precision", aPrecision );
- for (CORBA::ULong i = 0; i < n; i++) {
+ for ( int i = 0; i < n; i++) {
SMESH::Filter::Criterion aCriterion = createCriterion();
myTable->GetCriterion(i, aCriterion);
aCriterion.Precision = aPrecision;
//=======================================================================
void SMESHGUI_FilterDlg::insertFilterInViewer()
{
- if (SVTK_Selector* aSelector = SMESH::GetSelector()) {
+ if (SVTK_Selector* aSelector = SMESH::GetSelector())
+ {
SMESH::ElementType anEntType = (SMESH::ElementType)myTable->GetType();
if (myFilter[ myTable->GetType() ]->_is_nil() ||
{
SMESH::RemoveFilter(getFilterId(anEntType), aSelector);
}
- else {
+ else
+ {
Handle(SMESHGUI_PredicateFilter) aFilter = new SMESHGUI_PredicateFilter();
aFilter->SetPredicate(myFilter[ myTable->GetType() ]->GetPredicate());
SMESH::RemoveFilter(getFilterId(anEntType), aSelector); //skl for IPAL12631
{
if (myMesh->_is_nil())
return;
- SMESH::long_array_var anIds = myFilter[ theType ]->GetElementsId(myMesh);
+ SMESH::smIdType_array_var anIds = myFilter[ theType ]->GetElementsId(myMesh);
for (int i = 0, n = anIds->length(); i < n; i++)
- theResIds.append(anIds[ i ]);
+ theResIds.append(FromSmIdType<int>(anIds[ i ]));
}
else if (aSourceId == Selection)
{
if (aPred->IsSatisfy(*anIter))
theResIds.append(*anIter);
}
- // set ids to the dialog
- if (myInitSourceWgOnApply || aSourceId == Dialog)
- setIdsToWg(mySourceWg, theResIds);
}
//=======================================================================
// Create map of entities to be filtered
TColStd_MapOfInteger aToBeFiltered;
- SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter(myIObjects);
+ SALOME_DataMapIteratorOfIOMapOfVtk anIter(myIObjects);
for ( ; anIter.More(); anIter.Next())
{
{
if (aSubMesh->GetFather()->GetId() == myMesh->GetId())
{
- SMESH::long_array_var anIds =
+ SMESH::smIdType_array_var anIds =
theType == SMESH::NODE ? aSubMesh->GetNodesId() : aSubMesh->GetElementsId();
for (int i = 0, n = anIds->length(); i < n; i++)
- aToBeFiltered.Add(anIds[ i ]);
+ aToBeFiltered.Add(FromSmIdType<int>(anIds[ i ]));
}
}
{
if (aGroup->GetType() == theType && aGroup->GetMesh()->GetId() == myMesh->GetId())
{
- SMESH::long_array_var anIds = aGroup->GetListOfID();
+ SMESH::smIdType_array_var anIds = aGroup->GetListOfID();
for (int i = 0, n = anIds->length(); i < n; i++)
- aToBeFiltered.Add(anIds[ i ]);
+ aToBeFiltered.Add(FromSmIdType<int>(anIds[ i ]));
}
}
SMESH::SMESH_Mesh_var aMeshPtr = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIter.Key());
if (!aMeshPtr->_is_nil() && aMeshPtr->GetId() == myMesh->GetId())
{
- const TColStd_IndexedMapOfInteger& aSelMap = anIter.Value();
+ const SVTK_TIndexedMapOfVtkId& aSelMap = anIter.Value();
if (aSelMap.Extent() > 0)
{
theResIds.append(aResIter.Key());
}
+//=======================================================================
+//function : getActor
+//purpose : Returns an actor to show filtered entities
+//=======================================================================
+
+SMESH_Actor* SMESHGUI_FilterDlg::getActor()
+{
+ SMESH_Actor* meshActor = SMESH::FindActorByObject( myMesh );
+ if ( meshActor && meshActor->GetVisibility() )
+ return meshActor;
+
+ SALOME_DataMapIteratorOfIOMapOfVtk anIter(myIObjects);
+ for ( ; anIter.More(); anIter.Next())
+ {
+ Handle(SALOME_InteractiveObject) io = anIter.Key();
+ if ( io->hasEntry() )
+ {
+ SMESH_Actor* actor = SMESH::FindActorByEntry( io->getEntry() );
+ if ( !actor )
+ continue;
+ if ( actor->GetVisibility() )
+ return actor;
+ if ( !meshActor )
+ meshActor = actor;
+ }
+ }
+ return meshActor;
+}
+
//=======================================================================
// name : SMESHGUI_FilterDlg::selectInViewer
// Purpose : Select given entities in viewer
//=======================================================================
void SMESHGUI_FilterDlg::selectInViewer (const int theType, const QList<int>& theIds)
{
- if (mySelectionMgr == 0 || myMesh->_is_nil())
+ if (mySelectionMgr == 0 || myMesh->_is_nil() )
return;
mySelectionMgr->clearFilters();
// Set new selection mode if necessary
Selection_Mode aSelMode = getSelMode(theType);
SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );
- if ( aViewWindow && aViewWindow->SelectionMode()!=aSelMode) {
+ if ( aViewWindow && aViewWindow->SelectionMode() != aSelMode )
+ {
mySelectionMgr->clearSelected();
mySelectionMgr->clearFilters();
SMESH::SetPointRepresentation( aSelMode == NodeSelection );
}
// Clear selection
- SMESH_Actor* anActor = SMESH::FindActorByObject(myMesh);
- if (!anActor || !anActor->hasIO())
+ SMESH_Actor* anActor = getActor();
+ if ( !anActor || !anActor->hasIO() )
return;
Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
- //mySelectionMgr->clearSelected();
- //mySelectionMgr->AddIObject(anIO, false);
SALOME_ListIO aList;
aList.Append(anIO);
mySelectionMgr->setSelectedObjects(aList, false);
SMESH::RemoveFilter(aFilterId);
// get vtk ids
- TColStd_MapOfInteger aMap;
+ SVTK_TVtkIDsMap aMap;
QList<int>::const_iterator anIter;
for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter) {
aMap.Add(*anIter);
//=======================================================================
SMESH::Filter::Criterion SMESHGUI_FilterDlg::createCriterion()
{
- SMESH::Filter::Criterion aCriterion;
+ SMESH::Filter::Criterion aCriterion;
aCriterion.Type = SMESH::FT_Undefined;
aCriterion.Compare = SMESH::FT_Undefined;
void SMESHGUI_FilterDlg::onSelectionDone()
{
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()) ) {
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
- << SMESH::FT_ConnectedElements;
+ 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;
}
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() );
+ }
+ break;
+ }
default: // get a GEOM object
{
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());
+ myTable->SetID (aRow, anIO->getEntry());
}
}
}
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;
