1 // SMESH SMESHGUI : GUI for SMESH component
3 // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
24 // File : SMESHGUI_FilterDlg.cxx
25 // Author : Sergey LITONIN
28 #include "SMESHGUI_FilterDlg.h"
31 #include "SMESHGUI_Utils.h"
32 #include "SMESHGUI_VTKUtils.h"
33 #include "SMESHGUI_Filter.h"
34 #include "SMESHGUI_FilterUtils.h"
35 #include "SMESHGUI_FilterLibraryDlg.h"
37 #include "SMESH_Actor.h"
38 #include "SMESH_NumberFilter.hxx"
39 #include "SMESH_TypeFilter.hxx"
42 #include "GEOM_FaceFilter.h"
43 #include "GEOM_TypeFilter.h"
45 #include "SUIT_Desktop.h"
46 #include "SUIT_ResourceMgr.h"
48 #include "SalomeApp_Application.h"
49 #include "SalomeApp_Tools.h"
50 #include "SalomeApp_Study.h"
52 #include "SALOME_ListIO.hxx"
53 #include "SALOME_ListIteratorOfListIO.hxx"
54 #include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx"
55 #include "SALOMEDSClient_Study.hxx"
57 #include "SVTK_ViewWindow.h"
58 #include "SVTK_Selector.h"
61 #include <StdSelect_TypeOfFace.hxx>
62 #include <BRep_Tool.hxx>
64 #include <TopoDS_Face.hxx>
65 #include <TopoDS_Shape.hxx>
66 #include <Geom_Plane.hxx>
67 #include <Geom_CylindricalSurface.hxx>
68 #include <Precision.hxx>
69 #include <TColStd_MapOfInteger.hxx>
70 #include <TColStd_IndexedMapOfInteger.hxx>
71 #include <TColStd_MapIteratorOfMapOfInteger.hxx>
76 #include <qlineedit.h>
77 #include <qpushbutton.h>
78 #include <qgroupbox.h>
80 #include <qstringlist.h>
82 #include <qwidgetstack.h>
83 #include <qapplication.h>
84 #include <qcombobox.h>
85 #include <qfontmetrics.h>
86 #include <qmessagebox.h>
88 #include <qbuttongroup.h>
89 #include <qradiobutton.h>
92 #include <qcheckbox.h>
93 #include <qobjectlist.h>
94 #include <qvalidator.h>
97 #include "SALOMEconfig.h"
98 #include CORBA_SERVER_HEADER(SMESH_Group)
103 using namespace SMESH;
105 static int maxLength (const QMap<int, QString> theMap, const QFontMetrics& theMetrics)
108 QMap<int, QString>::const_iterator anIter;
109 for (anIter = theMap.begin(); anIter != theMap.end(); ++anIter)
110 aRes = Max(aRes, theMetrics.width(anIter.data()));
114 static int getFilterId (SMESH::ElementType theType)
118 case SMESH::NODE : return SMESHGUI_NodeFilter;
119 case SMESH::EDGE : return SMESHGUI_EdgeFilter;
120 case SMESH::FACE : return SMESHGUI_FaceFilter;
121 case SMESH::VOLUME : return SMESHGUI_VolumeFilter;
122 case SMESH::ALL : return SMESHGUI_AllElementsFilter;
123 default : return SMESHGUI_UnknownFilter;
128 Class : SMESHGUI_FilterTable::AdditionalWidget
129 Description : Class for storing additional parameters of criterion
132 class SMESHGUI_FilterTable::AdditionalWidget : public QFrame
139 AdditionalWidget(QWidget* theParent);
140 virtual ~AdditionalWidget();
142 virtual void GetParameters(QValueList<int>&) const;
143 virtual bool IsValid(const bool theMsg = true) const;
144 virtual double GetDouble(const int theId) const;
145 virtual int GetInteger(const int theId) const;
146 virtual QString GetString(const int theId) const;
147 virtual void SetDouble(const int theId, const double theVal);
148 virtual void SetInteger(const int theId, const int theVal);
149 virtual void SetString(const int theId, const QString& theVal);
150 void SetEditable(const int theId, const bool isEditable);
151 void SetEditable(const bool isEditable);
154 QMap< int, QLineEdit* > myLineEdits;
157 SMESHGUI_FilterTable::AdditionalWidget::AdditionalWidget (QWidget* theParent)
160 QLabel* aLabel = new QLabel(tr("SMESH_TOLERANCE"), this);
161 myLineEdits[ Tolerance ] = new QLineEdit(this);
162 QDoubleValidator* aValidator = new QDoubleValidator(myLineEdits[ Tolerance ]);
163 aValidator->setBottom(0);
164 myLineEdits[ Tolerance ]->setValidator(aValidator);
166 QHBoxLayout* aLay = new QHBoxLayout(this, 0, SPACING);
167 aLay->addWidget(aLabel);
168 aLay->addWidget(myLineEdits[ Tolerance ]);
170 QSpacerItem* aSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum);
171 aLay->addItem(aSpacer);
173 QString aText = QString("%1").arg(Precision::Confusion());
174 myLineEdits[ Tolerance ]->setText(aText);
177 SMESHGUI_FilterTable::AdditionalWidget::~AdditionalWidget()
181 void SMESHGUI_FilterTable::AdditionalWidget::GetParameters (QValueList<int>& theList) const
184 theList.append(Tolerance);
187 bool SMESHGUI_FilterTable::AdditionalWidget::IsValid (const bool theMsg) const
192 QValueList<int> aParams;
193 GetParameters(aParams);
194 QValueList<int>::const_iterator anIter;
195 for (anIter = aParams.begin(); anIter != aParams.end(); ++anIter) {
196 const QLineEdit* aWg = myLineEdits[ *anIter ];
198 QString aText = aWg->text();
199 if (aWg->isEnabled() && aWg->validator()->validate(aText, p) != QValidator::Acceptable) {
201 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
202 tr("SMESHGUI_INVALID_PARAMETERS"), QMessageBox::Ok);
210 double SMESHGUI_FilterTable::AdditionalWidget::GetDouble (const int theId) const
212 return myLineEdits.contains(theId) ? myLineEdits[ theId ]->text().toDouble() : 0;
215 int SMESHGUI_FilterTable::AdditionalWidget::GetInteger (const int theId) const
217 return myLineEdits.contains(theId) ? myLineEdits[ theId ]->text().toInt() : 0;
220 QString SMESHGUI_FilterTable::AdditionalWidget::GetString (const int theId) const
222 return myLineEdits.contains(theId) ? myLineEdits[ theId ]->text() : QString("");
225 void SMESHGUI_FilterTable::AdditionalWidget::SetDouble (const int theId, const double theVal)
227 if (myLineEdits.contains(theId))
228 myLineEdits[ theId ]->setText(QString("%1").arg(theVal));
231 void SMESHGUI_FilterTable::AdditionalWidget::SetInteger (const int theId, const int theVal)
233 if (myLineEdits.contains(theId))
234 myLineEdits[ theId ]->setText(QString("%1").arg(theVal));
237 void SMESHGUI_FilterTable::AdditionalWidget::SetString (const int theId, const QString& theVal)
239 if (myLineEdits.contains(theId))
240 myLineEdits[ theId ]->setText(theVal);
243 void SMESHGUI_FilterTable::AdditionalWidget::SetEditable (const int theId, const bool isEditable)
245 if (myLineEdits.contains(theId))
246 myLineEdits[ theId ]->setEdited(isEditable);
249 void SMESHGUI_FilterTable::AdditionalWidget::SetEditable (const bool isEditable)
251 QValueList<int> aParams;
252 GetParameters(aParams);
253 QValueList<int>::const_iterator anIter;
254 for (anIter = aParams.begin(); anIter != aParams.end(); ++anIter)
255 myLineEdits[ *anIter ]->setEdited(isEditable);
259 Class : SMESHGUI_FilterTable::ComboItem
260 Description : Combo table item. Identificator corresponding to string may be assigned
263 class SMESHGUI_FilterTable::ComboItem : public QComboTableItem
266 ComboItem(QTable*, const QMap<int, QString>&);
267 virtual ~ComboItem();
269 virtual void setStringList (const QStringList & l);
270 void setStringList(const QMap<int, QString>& theIds);
272 int GetValue() const;
273 void SetValue(const int);
277 QMap<int, int> myNumToId;
278 QMap<int, int> myIdToNum;
281 SMESHGUI_FilterTable::ComboItem::ComboItem (QTable* theParent,
282 const QMap<int, QString>& theIds)
283 : QComboTableItem(theParent, QStringList())
285 setStringList(theIds);
288 void SMESHGUI_FilterTable::ComboItem::setStringList (const QStringList & l)
290 QComboTableItem::setStringList(l);
293 void SMESHGUI_FilterTable::ComboItem::setStringList (const QMap<int, QString>& theIds)
297 QMap<int, QString>::const_iterator anIter;
298 for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter) {
299 myNumToId[ i ] = anIter.key();
300 myIdToNum[ anIter.key() ] = i;
301 aList.append(anIter.data());
305 setStringList(aList);
308 SMESHGUI_FilterTable::ComboItem::~ComboItem()
312 int SMESHGUI_FilterTable::ComboItem::GetValue() const
314 return myNumToId[ currentItem() ];
317 void SMESHGUI_FilterTable::ComboItem::SetValue (const int theVal)
319 setCurrentItem(myIdToNum[ theVal ]);
324 Class : SMESHGUI_FilterTable::Table
325 Description : Table used by this widget
328 class SMESHGUI_FilterTable::Table : public QTable
331 Table(QWidget* parent);
332 Table(int numRows, int numCols, QWidget* parent = 0);
335 void SetEditable(const bool state, const int row, const int col);
336 bool IsEditable(const int row, const int col) const;
338 virtual void insertRows(int row, int count = 1);
339 virtual QString text(int row, int col) const;
342 //=======================================================================
343 // name : SMESHGUI_FilterTable::Table::Table
344 // Purpose : Constructor
345 //=======================================================================
346 SMESHGUI_FilterTable::Table::Table (QWidget* parent)
347 : QTable(parent, "SMESHGUI_FilterTable::Table")
351 SMESHGUI_FilterTable::Table::Table (int numRows, int numCols, QWidget* parent)
352 : QTable(numRows, numCols, parent, "SMESHGUI_FilterTable::Table")
356 SMESHGUI_FilterTable::Table::~Table()
360 //=======================================================================
361 // name : SMESHGUI_FilterTable::Table::SetEditable
362 // Purpose : Set editable of specified cell
363 //=======================================================================
364 void SMESHGUI_FilterTable::Table::SetEditable (const bool isEditable,
365 const int row, const int col)
367 QTableItem* anItem = item(row, col);
372 setItem(row, col, new QTableItem(this, QTableItem::Never, ""));
374 setItem(row, col, new QTableItem(this, QTableItem::OnTyping, ""));
377 //=======================================================================
378 // name : SMESHGUI_FilterTable::Table::IsEditable
379 // Purpose : Verify wheter cell is editable
380 //=======================================================================
381 bool SMESHGUI_FilterTable::Table::IsEditable (const int row, const int col) const
383 QTableItem* anItem = item(row, col);
384 return anItem == 0 || anItem->editType() != QTableItem::Never;
387 //=======================================================================
388 // name : SMESHGUI_FilterTable::Table::insertRows
389 // Purpose : Insert rows (virtual redefined)
390 //=======================================================================
391 void SMESHGUI_FilterTable::Table::insertRows (int row, int count)
393 int anEditRow = currEditRow();
394 int anEditCol = currEditCol();
396 if (anEditRow >= 0 && anEditCol >= 0)
397 endEdit(anEditRow, anEditCol, true, false);
399 QTable::insertRows( row, count );
402 //=======================================================================
403 // name : SMESHGUI_FilterTable::Table::text
404 // Purpose : Get text from cell (virtual redefined)
405 //=======================================================================
406 QString SMESHGUI_FilterTable::Table::text (int row, int col) const
408 int anEditRow = currEditRow();
409 int anEditCol = currEditCol();
411 if (anEditRow >= 0 && anEditCol >= 0 && anEditRow == row && anEditCol == col)
412 ((Table*)this)->endEdit(row, col, true, false);
414 return QTable::text(row, col);
419 Class : SMESHGUI_FilterTable
420 Description : Frame containig
421 - Button group for switching entity type
422 - Table for displaying filter criterions
423 - Buttons for editing table and filter libraries
426 //=======================================================================
427 // name : SMESHGUI_FilterTable::SMESHGUI_FilterTable
428 // Purpose : Constructor
429 //=======================================================================
430 SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule,
435 mySMESHGUI( theModule )
441 //=======================================================================
442 // name : SMESHGUI_FilterTable::SMESHGUI_FilterTable
443 // Purpose : Constructor
444 //=======================================================================
445 SMESHGUI_FilterTable::SMESHGUI_FilterTable( SMESHGUI* theModule,
447 const QValueList<int>& types)
450 mySMESHGUI( theModule )
456 SMESHGUI_FilterTable::~SMESHGUI_FilterTable()
460 //=======================================================================
461 // name : SMESHGUI_FilterTable::Init
462 // Purpose : Create table corresponding to the specified type
463 //=======================================================================
464 void SMESHGUI_FilterTable::Init (const int type)
466 QValueList<int> aTypes;
471 //=======================================================================
472 // name : SMESHGUI_FilterTable::Init
473 // Purpose : Create table corresponding to the specified type
474 //=======================================================================
475 void SMESHGUI_FilterTable::Init (const QValueList<int>& theTypes)
477 if (theTypes.isEmpty())
480 // Create buttons if necessary
482 if (myTables.isEmpty())
484 int aType = theTypes.first();
486 // create main layout
487 QVBoxLayout* aMainLay = new QVBoxLayout(this);
488 QGroupBox* aMainGrp = new QGroupBox(1, Qt::Horizontal, this);
489 aMainGrp->setFrameStyle(QFrame::NoFrame);
490 aMainGrp->setInsideMargin(0);
491 aMainLay->addWidget(aMainGrp);
493 // create switch of entity types
494 myEntityTypeGrp = new QButtonGroup(1, Qt::Vertical, tr("ENTITY_TYPE"), aMainGrp);
495 const QMap<int, QString>& aSupportedTypes = getSupportedTypes();
496 QMap<int, QString>::const_iterator anIter;
497 for (anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter)
499 QRadioButton* aBtn = new QRadioButton(anIter.data(), myEntityTypeGrp);
500 myEntityTypeGrp->insert(aBtn, anIter.key());
503 myTableGrp = new QGroupBox(1, Qt::Horizontal, tr("FILTER"), aMainGrp );
504 QFrame* aTableFrame = new QFrame(myTableGrp);
507 mySwitchTableGrp = new QGroupBox(1, Qt::Horizontal, aTableFrame);
508 mySwitchTableGrp->setFrameStyle(QFrame::NoFrame);
509 mySwitchTableGrp->setInsideMargin(0);
511 myTables[ aType ] = createTable(mySwitchTableGrp, aType);
514 myAddBtn = new QPushButton(tr("ADD"), aTableFrame);
515 myRemoveBtn = new QPushButton(tr("REMOVE"), aTableFrame);
516 myClearBtn = new QPushButton(tr("CLEAR"), aTableFrame);
517 myInsertBtn = new QPushButton(tr("INSERT"), aTableFrame);
518 myCopyFromBtn = new QPushButton(tr("COPY_FROM"), aTableFrame);
519 myAddToBtn = new QPushButton(tr("ADD_TO"), aTableFrame);
521 myAddBtn->setAutoDefault(false);
522 myRemoveBtn->setAutoDefault(false);
523 myClearBtn->setAutoDefault(false);
524 myInsertBtn->setAutoDefault(false);
525 myCopyFromBtn->setAutoDefault(false);
526 myAddToBtn->setAutoDefault(false);
528 myCopyFromBtn->hide();
532 QGridLayout* aLay = new QGridLayout(aTableFrame, 8, 2, 0, SPACING);
534 aLay->addMultiCellWidget(mySwitchTableGrp, 0, 6, 0, 0);
535 aLay->addWidget(myAddBtn, 0, 1);
536 aLay->addWidget(myInsertBtn, 1, 1);
537 aLay->addWidget(myRemoveBtn, 2, 1);
538 aLay->addWidget(myClearBtn, 3, 1);
539 aLay->addWidget(myCopyFromBtn, 5, 1);
540 aLay->addWidget(myAddToBtn, 6, 1);
541 aLay->addMultiCellWidget(createAdditionalFrame(aTableFrame), 7, 7, 0, 1 );
543 aLay->setColStretch(0, 1);
544 aLay->setColStretch(1, 0);
546 QSpacerItem* aVSpacer = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
547 aLay->addItem(aVSpacer, 4, 1);
550 connect(myAddBtn, SIGNAL(clicked()), this, SLOT(onAddBtn()));
551 connect(myInsertBtn, SIGNAL(clicked()), this, SLOT(onInsertBtn()));
552 connect(myRemoveBtn, SIGNAL(clicked()), this, SLOT(onRemoveBtn()));
553 connect(myClearBtn, SIGNAL(clicked()), this, SLOT(onClearBtn()));
555 connect(myCopyFromBtn, SIGNAL(clicked()), this, SLOT(onCopyFromBtn()));
556 connect(myAddToBtn, SIGNAL(clicked()), this, SLOT(onAddToBtn()));
558 connect(myEntityTypeGrp, SIGNAL(clicked(int)), this, SLOT(onEntityType(int)));
563 // Hide buttons of entity types if necessary
564 const QMap<int, QString>& aSupportedTypes = getSupportedTypes();
565 QMap<int, QString>::const_iterator anIt;
566 for (anIt = aSupportedTypes.begin(); anIt != aSupportedTypes.end(); ++anIt)
568 QButton* aBtn = myEntityTypeGrp->find(anIt.key());
569 theTypes.contains(anIt.key()) ? aBtn->show() : aBtn->hide();
572 // select first button if there is no selected buttons or it is hidden
573 QButton* aBtn = myEntityTypeGrp->selected();
574 if ( aBtn == 0 || theTypes.find(myEntityTypeGrp->id(aBtn)) == theTypes.end())
575 myEntityTypeGrp->setButton(theTypes.first());
577 if (theTypes.count() == 1)
578 myEntityTypeGrp->hide();
580 myEntityTypeGrp->show();
582 myTableGrp->updateGeometry();
583 int aType = myEntityTypeGrp->id(myEntityTypeGrp->selected());
587 //=======================================================================
588 // name : SMESHGUI_FilterTable::GetTableGrp
589 // Purpose : Get group box containing table. May be used for adding new widgets in it
590 //=======================================================================
591 QWidget* SMESHGUI_FilterTable::createAdditionalFrame (QWidget* theParent)
593 QFrame* aFrame = new QFrame(theParent);
595 QFrame* aLine1 = new QFrame(aFrame);
596 QFrame* aLine2 = new QFrame(aFrame);
597 aLine1->setFrameStyle(QFrame::HLine | QFrame::Sunken);
598 aLine2->setFrameStyle(QFrame::HLine | QFrame::Sunken);
599 aLine1->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
600 aLine2->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
602 QLabel* aLabel = new QLabel(tr("ADDITIONAL_PARAMETERS"), aFrame);
604 myWgStack = new QWidgetStack(aFrame);
606 QGridLayout* aLay = new QGridLayout(aFrame, 2, 3, 0, SPACING);
607 aLay->addWidget(aLine1, 0, 0);
608 aLay->addWidget(aLabel, 0, 1);
609 aLay->addWidget(aLine2, 0, 2);
610 aLay->addMultiCellWidget(myWgStack, 1, 1, 0, 2);
615 //=======================================================================
616 // name : SMESHGUI_FilterTable::GetTableGrp
617 // Purpose : Get group box containing table. May be used for adding new widgets in it
618 //=======================================================================
619 QGroupBox* SMESHGUI_FilterTable::GetTableGrp()
624 //=======================================================================
625 // name : SMESHGUI_FilterTable::onEntityType
626 // Purpose : SLOT. Called when entity type changed.
627 // Display corresponding table
628 //=======================================================================
629 void SMESHGUI_FilterTable::onEntityType (int theType)
631 if (myEntityType == theType)
635 emit NeedValidation();
638 myEntityTypeGrp->setButton(myEntityType);
642 myEntityType = theType;
644 if (!myTables.contains(theType))
645 myTables[ theType ] = createTable(mySwitchTableGrp, theType);
647 TableMap::iterator anIter;
648 for (anIter = myTables.begin(); anIter != myTables.end(); ++anIter)
649 myEntityType == anIter.key() ? anIter.data()->show() : anIter.data()->hide();
652 qApp->processEvents();
653 myTables[ myEntityType ]->updateGeometry();
656 emit EntityTypeChanged(theType);
660 //=======================================================================
661 // name : SMESHGUI_FilterTable::IsValid
662 // Purpose : Verify validity of entered data
663 //=======================================================================
664 bool SMESHGUI_FilterTable::IsValid (const bool theMess, const int theEntityType) const
666 int aType = theEntityType == -1 ? GetType() : theEntityType;
668 Table* aTable = myTables[ aType ];
669 for (int i = 0, n = aTable->numRows(); i < n; i++)
671 int aCriterion = GetCriterionType(i, aType);
673 if (aCriterion == FT_RangeOfIds ||
674 aCriterion == FT_BelongToGeom ||
675 aCriterion == FT_BelongToPlane ||
676 aCriterion == FT_BelongToCylinder ||
677 aCriterion == FT_LyingOnGeom) {
678 if (aTable->text(i, 2).isEmpty()) {
680 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
681 tr("ERROR"), QMessageBox::Ok);
686 aTable->blockSignals(true);
687 double aThreshold = (int)aTable->text(i, 2).toDouble(&aRes);
688 aTable->blockSignals(false);
690 if (!aRes && aTable->IsEditable(i, 2)) {
692 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
693 tr("ERROR"), QMessageBox::Ok);
696 else if (aType == SMESH::EDGE &&
697 GetCriterionType(i, aType) == SMESH::FT_MultiConnection &&
701 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
702 tr("MULTIEDGES_ERROR"), QMessageBox::Ok);
707 QTableItem* anItem = aTable->item(i, 0);
708 if (myAddWidgets.contains(anItem) && !myAddWidgets[ anItem ]->IsValid())
715 //=======================================================================
716 // name : SMESHGUI_FilterTable::SetValidity
717 // Purpose : Set validity of the table
718 //=======================================================================
719 void SMESHGUI_FilterTable::SetValidity (const bool isValid)
724 //=======================================================================
725 // name : SMESHGUI_FilterTable::GetType
726 // Purpose : Get current entity type
727 //=======================================================================
728 int SMESHGUI_FilterTable::GetType() const
733 //=======================================================================
734 // name : SMESHGUI_FilterTable::SetType
735 // Purpose : Set current entity type
736 //=======================================================================
737 void SMESHGUI_FilterTable::SetType (const int type)
739 myEntityTypeGrp->setButton(type);
743 //=======================================================================
744 // name : SMESHGUI_FilterTable::RestorePreviousEntityType
745 // Purpose : Restore previous entity type
746 //=======================================================================
747 void SMESHGUI_FilterTable::RestorePreviousEntityType()
749 SetType(myEntityType);
752 //=======================================================================
753 // name : SMESHGUI_FilterTable::GetCriterionType
754 // Purpose : Get type of criterion from specified row (corresponding enums in h-file)
755 //=======================================================================
756 int SMESHGUI_FilterTable::GetCriterionType (const int theRow, const int theType) const
758 int aType = theType == -1 ? GetType() : theType;
759 Table* aTable = myTables[ aType ];
760 ComboItem* anItem = (ComboItem*)aTable->item(theRow, 0);
761 return anItem != 0 ? anItem->GetValue() : FT_Undefined;
764 //=======================================================================
765 // name : SMESHGUI_FilterTable::GetCriterion
766 // Purpose : Get parameters of criterion from specified row
767 //=======================================================================
768 void SMESHGUI_FilterTable::GetCriterion (const int theRow,
769 SMESH::Filter::Criterion& theCriterion,
770 const int theEntityType) const
772 int aType = theEntityType == -1 ? GetType() : theEntityType;
773 Table* aTable = myTables[ aType ];
775 theCriterion.Type = ((ComboItem*)aTable->item(theRow, 0))->GetValue();
776 theCriterion.UnaryOp = ((QCheckTableItem*)aTable->item(theRow, 3))->isChecked() ? FT_LogicalNOT : FT_Undefined;
777 theCriterion.BinaryOp = theRow != aTable->numRows() - 1 ?
778 ((ComboItem*)aTable->item(theRow, 4))->GetValue() : FT_Undefined;
779 theCriterion.TypeOfElement = (ElementType)aType;
781 int aCriterionType = GetCriterionType(theRow, aType);
783 if (aCriterionType != FT_RangeOfIds &&
784 aCriterionType != FT_BelongToGeom &&
785 aCriterionType != FT_BelongToPlane &&
786 aCriterionType != FT_BelongToCylinder &&
787 aCriterionType != FT_LyingOnGeom)
789 theCriterion.Compare = ((ComboItem*)aTable->item(theRow, 1))->GetValue();
790 theCriterion.Threshold = aTable->item(theRow, 2)->text().toDouble();
793 theCriterion.ThresholdStr = aTable->text(theRow, 2).latin1();
795 QTableItem* anItem = aTable->item(theRow, 0);
796 if (myAddWidgets.contains(anItem))
797 theCriterion.Tolerance = myAddWidgets[ anItem ]->GetDouble(AdditionalWidget::Tolerance);
800 //=======================================================================
801 // name : SMESHGUI_FilterTable::SetCriterion
802 // Purpose : Set parameters of criterion of specified row
803 //=======================================================================
804 void SMESHGUI_FilterTable::SetCriterion (const int theRow,
805 const SMESH::Filter::Criterion& theCriterion,
806 const int theEntityType)
808 int aType = theEntityType == -1 ? GetType() : theEntityType;
810 Table* aTable = myTables[ aType ];
812 if (theRow > aTable->numRows() - 1)
815 ((ComboItem*)aTable->item(theRow, 0))->SetValue(theCriterion.Type);
816 onCriterionChanged(theRow, 0, aType);
817 ((ComboItem*)aTable->item(theRow, 1))->SetValue(theCriterion.Compare);
818 ((QCheckTableItem*)aTable->item(theRow, 3))->setChecked(theCriterion.UnaryOp == FT_LogicalNOT);
820 if (theCriterion.BinaryOp != FT_Undefined)
822 if (!aTable->IsEditable(theRow, 4))
823 aTable->setItem(theRow, 4, getBinaryItem(aTable));
824 ((ComboItem*)aTable->item(theRow, 4))->SetValue(theCriterion.BinaryOp);
827 aTable->SetEditable(false, theRow, 4);
829 if (theCriterion.Type != FT_RangeOfIds &&
830 theCriterion.Type != FT_BelongToGeom &&
831 theCriterion.Type != FT_BelongToPlane &&
832 theCriterion.Type != FT_BelongToCylinder &&
833 theCriterion.Type != FT_LyingOnGeom)
834 aTable->setText(theRow, 2, QString("%1").arg(theCriterion.Threshold, 0, 'g', 15));
836 aTable->setText(theRow, 2, QString(theCriterion.ThresholdStr));
838 if (theCriterion.Compare == FT_EqualTo ||
839 theCriterion.Type == FT_BelongToPlane ||
840 theCriterion.Type == FT_BelongToCylinder)
842 QTableItem* anItem = aTable->item(theRow, 0);
843 if (!myAddWidgets.contains(anItem))
845 myAddWidgets[ anItem ] = new AdditionalWidget(myWgStack);
846 myWgStack->addWidget(myAddWidgets[ anItem ]);
848 myAddWidgets[ anItem ]->SetDouble(AdditionalWidget::Tolerance, theCriterion.Tolerance);
851 emit CriterionChanged(theRow, aType);
855 //=======================================================================
856 // name : SMESHGUI_FilterTable::Update
857 // Purpose : Update table
858 //=======================================================================
859 void SMESHGUI_FilterTable::Update()
861 Table* aTable = myTables[ GetType() ];
862 int aCurrRow = aTable->currentRow();
863 int numRows = aTable->numRows();
864 if ((aCurrRow < 0 || aCurrRow >= numRows) && numRows > 0)
865 aTable->setCurrentCell(0, 0);
866 updateAdditionalWidget();
869 //=======================================================================
870 // name : SMESHGUI_FilterTable::AddCriterion
871 // Purpose : Add criterion with parameters
872 //=======================================================================
873 void SMESHGUI_FilterTable::AddCriterion (const SMESH::Filter::Criterion& theCriterion,
874 const int theEntityType)
876 int aType = theEntityType == -1 ? GetType() : theEntityType;
877 Table* aTable = myTables[ aType ];
878 addRow(aTable, aType);
879 SetCriterion(aTable->numRows() - 1, theCriterion);
882 //=======================================================================
883 // name : SMESHGUI_FilterTable::NumRows
884 // Purpose : Get number of criterions of current type
885 //=======================================================================
886 int SMESHGUI_FilterTable::NumRows (const int theEntityType) const
888 return myTables[ theEntityType == -1 ? GetType() : theEntityType ]->numRows();
891 //=======================================================================
892 // name : SMESHGUI_FilterTable::Clear
893 // Purpose : Clear current table
894 //=======================================================================
895 void SMESHGUI_FilterTable::Clear (const int theType)
897 int aType = theType == -1 ? GetType() : theType;
898 QTable* aTable = myTables[ aType ];
900 if (aTable->numRows() == 0)
903 while (aTable->numRows() > 0)
905 removeAdditionalWidget(aTable, 0);
906 aTable->removeRow(0);
912 //=======================================================================
913 // name : SMESHGUI_FilterTable::onAddBtn
914 // Purpose : SLOT. Called then "Add" button pressed.
915 // Adds new string to table
916 //=======================================================================
917 void SMESHGUI_FilterTable::onAddBtn()
919 int aType = GetType();
920 addRow(myTables[ aType ], aType);
925 //=======================================================================
926 // name : SMESHGUI_FilterTable::onInsertBtn
927 // Purpose : SLOT. Called then "Insert" button pressed.
928 // Inserts new string before current one
929 //=======================================================================
930 void SMESHGUI_FilterTable::onInsertBtn()
932 addRow(myTables[ GetType() ], GetType(), false);
935 //=======================================================================
936 // name : SMESHGUI_FilterTable::onRemoveBtn
937 // Purpose : SLOT. Called then "Remove" button pressed.
938 // Removes current string from table
939 //=======================================================================
940 void SMESHGUI_FilterTable::onRemoveBtn()
942 Table* aTable = myTables[ GetType() ];
944 if (aTable->numRows() == 0)
947 QMemArray<int> aRows;
948 for (int i = 0, n = aTable->numRows(); i < n; i++)
950 if (aTable->isRowSelected(i))
952 aRows.resize(aRows.size() + 1);
953 aRows[ aRows.size() - 1 ] = i;
954 removeAdditionalWidget(aTable, i);
958 aTable->removeRows(aRows);
960 // remove control of binary logical operation from last row
961 if (aTable->numRows() > 0)
962 aTable->SetEditable(false, aTable->numRows() - 1, 4);
967 //=======================================================================
968 // name : SMESHGUI_FilterTable::updateAdditionalWidget
969 // Purpose : Enable/Disable widget with additonal parameters
970 //=======================================================================
971 void SMESHGUI_FilterTable::updateAdditionalWidget()
973 Table* aTable = myTables[ GetType() ];
974 int aRow = aTable->currentRow();
975 if (aRow < 0 || aRow >= aTable->numRows())
977 myWgStack->setEnabled(false);
981 ComboItem* anItem = ((ComboItem*)aTable->item(aRow, 0));
982 bool toEnable = ((ComboItem*)aTable->item(aRow, 1))->GetValue() == FT_EqualTo &&
983 GetCriterionType(aRow) != FT_BelongToGeom &&
984 GetCriterionType(aRow) != FT_LyingOnGeom &&
985 GetCriterionType(aRow) != FT_RangeOfIds &&
986 GetCriterionType(aRow) != FT_FreeEdges &&
987 GetCriterionType(aRow) != FT_BadOrientedVolume;
988 if (!myAddWidgets.contains(anItem))
990 myAddWidgets[ anItem ] = new AdditionalWidget(myWgStack);
991 myWgStack->addWidget(myAddWidgets[ anItem ]);
994 myWgStack->raiseWidget(myWgStack->id(myAddWidgets[ anItem ]));
995 myWgStack->setEnabled(toEnable);
998 //=======================================================================
999 // name : SMESHGUI_FilterTable::removeAdditionalWidget
1000 // Purpose : Remove widgets containing additional parameters from widget
1001 // stack and internal map
1002 //=======================================================================
1003 void SMESHGUI_FilterTable::removeAdditionalWidget (QTable* theTable, const int theRow)
1005 QTableItem* anItem = theTable->item(theRow, 0);
1006 if (myAddWidgets.contains(anItem))
1008 myWgStack->removeWidget(myAddWidgets[ anItem ]);
1009 myAddWidgets[ anItem ]->reparent(0, QPoint());
1010 delete myAddWidgets[ anItem ];
1011 myAddWidgets.remove(anItem);
1015 //=======================================================================
1016 // name : SMESHGUI_FilterTable::onClearBtn
1017 // Purpose : SLOT. Called then "Clear" button pressed.
1018 // Removes all strings from table
1019 //=======================================================================
1020 void SMESHGUI_FilterTable::onClearBtn()
1022 QTable* aTable = myTables[ GetType() ];
1024 if (aTable->numRows() == 0)
1027 while (aTable->numRows() > 0)
1029 removeAdditionalWidget(aTable, 0);
1030 aTable->removeRow(0);
1036 //=======================================================================
1037 // name : SMESHGUI_FilterTable::onCurrentChanged()
1038 // Purpose : SLOT. Called when current cell changed
1039 //=======================================================================
1040 void SMESHGUI_FilterTable::onCurrentChanged (int theRow, int theCol)
1043 updateAdditionalWidget();
1044 emit CurrentChanged(theRow, theCol);
1047 //=======================================================================
1048 // name : SMESHGUI_FilterTable::onCriterionChanged()
1049 // Purpose : Provides reaction on change of criterion
1050 //=======================================================================
1051 void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int entityType)
1053 int aType = entityType == -1 ? GetType() : entityType;
1054 Table* aTable = myTables[ aType ];
1055 ComboItem* aCompareItem = (ComboItem*)aTable->item(row, 1);
1057 int aCriterionType = GetCriterionType(row);
1059 if (aType == SMESH::EDGE && aCriterionType == SMESH::FT_FreeBorders ||
1060 aType == SMESH::FACE && aCriterionType == SMESH::FT_FreeEdges ||
1061 aType == SMESH::VOLUME && aCriterionType == SMESH::FT_BadOrientedVolume)
1063 if (aCompareItem->count() > 0)
1064 aCompareItem->setStringList(QStringList());
1065 aTable->SetEditable(false, row, 2);
1067 else if (aCriterionType == SMESH::FT_RangeOfIds ||
1068 aCriterionType == SMESH::FT_BelongToGeom ||
1069 aCriterionType == SMESH::FT_BelongToPlane ||
1070 aCriterionType == SMESH::FT_BelongToCylinder ||
1071 aCriterionType == SMESH::FT_LyingOnGeom)
1073 QMap<int, QString> aMap;
1074 aMap[ FT_EqualTo ] = tr("EQUAL_TO");
1075 aCompareItem->setStringList(aMap);
1076 if (!aTable->IsEditable(row, 2))
1077 aTable->SetEditable(true, row, 2);
1081 if (aCompareItem->count() != 3)
1083 aCompareItem->setStringList(QStringList());
1084 aCompareItem->setStringList(getCompare());
1087 QString aText = aTable->text(row, 2);
1089 aText.toDouble(&isOk);
1090 aTable->setText(row, 2, isOk ? aText : QString(""));
1091 if (!aTable->IsEditable(row, 2))
1092 aTable->SetEditable(true, row, 2);
1095 updateAdditionalWidget();
1097 emit CriterionChanged(row, entityType);
1100 //=======================================================================
1101 // name : SMESHGUI_FilterTable::onCriterionChanged()
1102 // Purpose : SLOT. Called then contents of table changed
1103 // Provides reaction on change of criterion
1104 //=======================================================================
1105 void SMESHGUI_FilterTable::onCriterionChanged (int row, int col)
1107 onCriterionChanged(row, col, -1);
1110 //=======================================================================
1111 // name : SMESHGUI_FilterTable::getFirstSelectedRow
1112 // Purpose : Get first selected row
1113 //=======================================================================
1114 int SMESHGUI_FilterTable::getFirstSelectedRow() const
1116 QTable* aTable = myTables[ GetType() ];
1117 for (int i = 0, n = aTable->numRows(); i < n; i++)
1118 if (aTable->isRowSelected(i))
1121 int aRow = aTable->currentRow();
1122 return aRow >= 0 && aRow < aTable->numRows() ? aRow : -1;
1125 //=======================================================================
1126 // name : SMESHGUI_FilterTable::addRow
1127 // Purpose : Add row at the end of table
1128 //=======================================================================
1129 void SMESHGUI_FilterTable::addRow (Table* theTable, const int theType, const bool toTheEnd)
1132 int aSelectedRow = getFirstSelectedRow();
1133 int aCurrCol = theTable->currentColumn();
1136 if (toTheEnd || aSelectedRow == -1)
1138 theTable->insertRows(theTable->numRows());
1139 aCurrRow = theTable->numRows() - 1;
1143 theTable->insertRows(aSelectedRow);
1144 aCurrRow = aSelectedRow;
1149 theTable->setItem(aCurrRow, 0, getCriterionItem(theTable, theType));
1152 theTable->setItem(aCurrRow, 1, getCompareItem(theTable));
1155 //theTable->setItem(aCurrRow, 2, new QTableItem(theTable));
1157 //Logical operation NOT
1158 theTable->setItem(aCurrRow, 3, getUnaryItem(theTable));
1160 // Logical binary operation for previous value
1161 int anAddBinOpStr = -1;
1162 if (aCurrRow == theTable->numRows() - 1)
1163 anAddBinOpStr = aCurrRow - 1;
1164 else if (aCurrRow >= 0 )
1165 anAddBinOpStr = aCurrRow;
1167 if (theTable->item(aCurrRow, 4) == 0 ||
1168 theTable->item(aCurrRow, 4)->rtti() != 1)
1172 if (anAddBinOpStr >= 0 &&
1173 (theTable->item(anAddBinOpStr, 4) == 0 ||
1174 theTable->item(anAddBinOpStr, 4)->rtti() != 1))
1175 theTable->setItem(anAddBinOpStr, 4, getBinaryItem(theTable));
1178 theTable->SetEditable(false, theTable->numRows() - 1, 4);
1180 if (aCurrRow >=0 && aCurrRow < theTable->numRows() &&
1181 aCurrCol >=0 && aCurrCol < theTable->numRows())
1182 theTable->setCurrentCell(aCurrRow, aCurrCol);
1184 onCriterionChanged(aCurrRow, 0);
1189 //=======================================================================
1190 // name : SMESHGUI_FilterTable::getCriterionItem
1191 // Purpose : Get combo table item for criteria of specified type
1192 //=======================================================================
1193 QTableItem* SMESHGUI_FilterTable::getCriterionItem (QTable* theParent , const int theType)
1195 return new ComboItem(theParent, getCriteria(theType));
1198 //=======================================================================
1199 // name : SMESHGUI_FilterTable::getCompareItem
1200 // Purpose : Get combo table item for operation of comparision
1201 //=======================================================================
1202 QTableItem* SMESHGUI_FilterTable::getCompareItem (QTable* theParent)
1204 return new ComboItem(theParent, getCompare());
1207 //=======================================================================
1208 // name : SMESHGUI_FilterTable::getBinaryItem
1210 //=======================================================================
1211 QTableItem* SMESHGUI_FilterTable::getBinaryItem (QTable* theParent)
1213 static QMap<int, QString> aMap;
1216 aMap[ SMESH::FT_LogicalAND ] = tr("AND");
1217 aMap[ SMESH::FT_LogicalOR ] = tr("OR");
1220 return new ComboItem(theParent, aMap);
1223 //=======================================================================
1224 // name : SMESHGUI_FilterTable::getUnaryItem
1225 // Purpose : Get check table item
1226 //=======================================================================
1227 QTableItem* SMESHGUI_FilterTable::getUnaryItem (QTable* theParent)
1229 return new QCheckTableItem(theParent, tr("NOT"));
1232 //=======================================================================
1233 // name : SMESHGUI_FilterTable::getSupportedTypes
1234 // Purpose : Get all supported type
1235 //=======================================================================
1236 const QMap<int, QString>& SMESHGUI_FilterTable::getSupportedTypes() const
1238 static QMap<int, QString> aTypes;
1239 if (aTypes.isEmpty())
1241 aTypes[ SMESH::NODE ] = tr("NODES");
1242 aTypes[ SMESH::EDGE ] = tr("EDGES");
1243 aTypes[ SMESH::FACE ] = tr("FACES");
1244 aTypes[ SMESH::VOLUME ] = tr("VOLUMES");
1250 //=======================================================================
1251 // name : SMESHGUI_FilterTable::getCriteria
1252 // Purpose : Get criteria for specified type
1253 //=======================================================================
1254 const QMap<int, QString>& SMESHGUI_FilterTable::getCriteria (const int theType) const
1256 if (theType == SMESH::NODE)
1258 static QMap<int, QString> aCriteria;
1259 if (aCriteria.isEmpty())
1261 aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS");
1262 aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM");
1263 aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE");
1264 aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER");
1265 aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM");
1269 else if (theType == SMESH::EDGE)
1271 static QMap<int, QString> aCriteria;
1272 if (aCriteria.isEmpty())
1274 aCriteria[ SMESH::FT_FreeBorders ] = tr("FREE_BORDERS");
1275 aCriteria[ SMESH::FT_MultiConnection ] = tr("MULTI_BORDERS");
1276 aCriteria[ SMESH::FT_Length ] = tr("LENGTH");
1277 aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS");
1278 aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM");
1279 aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE");
1280 aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER");
1281 aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM");
1285 else if (theType == SMESH::FACE)
1287 static QMap<int, QString> aCriteria;
1288 if (aCriteria.isEmpty())
1290 aCriteria[ SMESH::FT_AspectRatio ] = tr("ASPECT_RATIO");
1291 aCriteria[ SMESH::FT_Warping ] = tr("WARPING");
1292 aCriteria[ SMESH::FT_MinimumAngle ] = tr("MINIMUM_ANGLE");
1293 aCriteria[ SMESH::FT_Taper ] = tr("TAPER");
1294 aCriteria[ SMESH::FT_Skew ] = tr("SKEW");
1295 aCriteria[ SMESH::FT_Area ] = tr("AREA");
1296 aCriteria[ SMESH::FT_FreeEdges ] = tr("FREE_EDGES");
1297 aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS");
1298 aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM");
1299 aCriteria[ SMESH::FT_BelongToPlane ] = tr("BELONG_TO_PLANE");
1300 aCriteria[ SMESH::FT_BelongToCylinder ] = tr("BELONG_TO_CYLINDER");
1301 aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM");
1302 aCriteria[ SMESH::FT_Length2D ] = tr("LENGTH2D");
1303 aCriteria[ SMESH::FT_MultiConnection2D] = tr("MULTI2D_BORDERS");
1307 else if (theType == SMESH::VOLUME)
1309 static QMap<int, QString> aCriteria;
1310 if (aCriteria.isEmpty())
1312 aCriteria[ SMESH::FT_AspectRatio3D] = tr("ASPECT_RATIO_3D");
1313 aCriteria[ SMESH::FT_RangeOfIds ] = tr("RANGE_OF_IDS");
1314 aCriteria[ SMESH::FT_BelongToGeom ] = tr("BELONG_TO_GEOM");
1315 aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM");
1316 aCriteria[ SMESH::FT_BadOrientedVolume ] = tr("BAD_ORIENTED_VOLUME");
1317 aCriteria[ SMESH::FT_Volume3D ] = tr("VOLUME_3D");
1323 static QMap<int, QString> aCriteria;
1329 //=======================================================================
1330 // name : SMESHGUI_FilterTable::getCompare
1331 // Purpose : Get operation of comparison
1332 //=======================================================================
1333 const QMap<int, QString>& SMESHGUI_FilterTable::getCompare() const
1335 static QMap<int, QString> aMap;
1339 aMap[ SMESH::FT_LessThan ] = tr("LESS_THAN");
1340 aMap[ SMESH::FT_MoreThan ] = tr("MORE_THAN");
1341 aMap[ SMESH::FT_EqualTo ] = tr("EQUAL_TO" );
1347 //=======================================================================
1348 // name : SMESHGUI_FilterTable::createTable
1349 // Purpose : Create table
1350 //=======================================================================
1351 SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* theParent,
1355 Table* aTable= new Table(0, 5, theParent);
1357 QHeader* aHeaders = aTable->horizontalHeader();
1359 QFontMetrics aMetrics(aHeaders->font());
1361 // append spaces to the header of criteria in order to
1362 // provide visibility of criterion inside comboboxes
1363 static int aMaxLenCr = 0;
1367 const QMap<int, QString>& aSupportedTypes = getSupportedTypes();
1368 QMap<int, QString>::const_iterator anIter;
1369 for (anIter = aSupportedTypes.begin(); anIter != aSupportedTypes.end(); ++anIter)
1370 aMaxLenCr = Max(maxLength(getCriteria(anIter.key()), aMetrics), aMaxLenCr);
1373 static int aLenCr = abs( aMaxLenCr -
1374 aMetrics.width(tr("CRITERION"))) / aMetrics.width(' ') + 5;
1377 aCrStr.fill(' ', aLenCr);
1379 aCoStr.fill(' ', 10);
1381 aHeaders->setLabel(0, tr("CRITERION") + aCrStr);
1382 aHeaders->setLabel(1, tr("COMPARE") + aCoStr);
1383 aHeaders->setLabel(2, tr("THRESHOLD_VALUE"));
1384 aHeaders->setLabel(3, tr("UNARY"));
1385 aHeaders->setLabel(4, tr("BINARY") + " ");
1387 // set geometry of the table
1388 for (int i = 0; i <= 4; i++)
1389 aTable->adjustColumn(i);
1391 aTable->updateGeometry();
1392 QSize aSize = aTable->sizeHint();
1393 int aWidth = aSize.width();
1394 aTable->setMinimumSize(QSize(aWidth, aWidth / 2));
1395 aTable->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
1397 connect(aTable, SIGNAL(valueChanged(int, int)),
1398 this, SLOT(onCriterionChanged(int, int)));
1400 connect(aTable, SIGNAL(currentChanged(int, int)),
1401 this, SLOT(onCurrentChanged(int, int)));
1406 //=======================================================================
1407 // name : SMESHGUI_FilterTable::updateBtnState
1408 // Purpose : Update button state
1409 //=======================================================================
1410 void SMESHGUI_FilterTable::updateBtnState()
1412 myRemoveBtn->setEnabled(myTables[ GetType() ]->numRows() > 0);
1413 myClearBtn->setEnabled(myTables[ GetType() ]->numRows() > 0);
1416 //=======================================================================
1417 // name : SMESHGUI_FilterTable::SetEditable
1418 // Purpose : Set read only flag for tables. Show/hide buttons for work with rows
1419 //=======================================================================
1420 void SMESHGUI_FilterTable::SetEditable (const bool isEditable)
1422 TableMap::iterator anIter;
1423 for (anIter = myTables.begin(); anIter != myTables.end(); ++anIter)
1425 anIter.data()->setReadOnly(!isEditable);
1430 myInsertBtn->show();
1431 myRemoveBtn->show();
1437 myInsertBtn->hide();
1438 myRemoveBtn->hide();
1443 QMap<QTableItem*, AdditionalWidget*>::iterator anIter2;
1444 for (anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2)
1445 anIter2.data()->SetEditable(isEditable);
1448 //=======================================================================
1449 // name : SMESHGUI_FilterTable::SetEnabled
1450 // Purpose : Enable/Disable table. Switching type of elements already enabled
1451 //=======================================================================
1452 void SMESHGUI_FilterTable::SetEnabled (const bool isEnabled)
1454 myAddBtn->setEnabled(isEnabled);
1455 myInsertBtn->setEnabled(isEnabled);
1456 myRemoveBtn->setEnabled(isEnabled);
1457 myClearBtn->setEnabled(isEnabled);
1462 QMap<QTableItem*, AdditionalWidget*>::iterator anIter2;
1463 for (anIter2 = myAddWidgets.begin(); anIter2 != myAddWidgets.end(); ++anIter2)
1464 anIter2.data()->setEnabled(isEnabled);
1467 //=======================================================================
1468 // name : SMESHGUI_FilterTable::IsEditable
1469 // Purpose : Verify whether table is editable
1470 //=======================================================================
1471 bool SMESHGUI_FilterTable::IsEditable() const
1473 return !myTables[ GetType() ]->isReadOnly();
1476 //=======================================================================
1477 // name : SMESHGUI_FilterTable::SetLibsEnabled
1478 // Purpose : Show/hide buttons for work with libraries
1479 //=======================================================================
1480 void SMESHGUI_FilterTable::SetLibsEnabled (const bool isEnabled)
1484 myCopyFromBtn->show();
1489 myCopyFromBtn->hide();
1494 //=======================================================================
1495 // name : SMESHGUI_FilterTable::onCopyFromBtn
1496 // Purpose : SLOT. Called the "Copy from ..." button clicked
1497 // Display filter library dialog
1498 //=======================================================================
1499 void SMESHGUI_FilterTable::onCopyFromBtn()
1502 myLibDlg = new SMESHGUI_FilterLibraryDlg(
1503 mySMESHGUI, this, GetType(), SMESHGUI_FilterLibraryDlg::COPY_FROM);
1505 myLibDlg->Init(GetType(), SMESHGUI_FilterLibraryDlg::COPY_FROM);
1507 if (myLibDlg->exec() == QDialog::Accepted)
1509 Copy(myLibDlg->GetTable());
1514 //=======================================================================
1515 // name : SMESHGUI_FilterTable::onAddToBtn
1516 // Purpose : SLOT. Called the "Add to ..." button clicked
1517 // Display filter library dialog
1518 //=======================================================================
1519 void SMESHGUI_FilterTable::onAddToBtn()
1524 myLibDlg = new SMESHGUI_FilterLibraryDlg(
1525 mySMESHGUI, this, GetType(), SMESHGUI_FilterLibraryDlg::ADD_TO);
1527 myLibDlg->Init(GetType(), SMESHGUI_FilterLibraryDlg::ADD_TO);
1529 myLibDlg->SetTable(this);
1534 //=======================================================================
1535 // name : SMESHGUI_FilterTable::Copy
1536 // Purpose : Initialise table with values of other table
1537 //=======================================================================
1538 void SMESHGUI_FilterTable::Copy (const SMESHGUI_FilterTable* theTable)
1542 for (int i = 0, n = theTable->NumRows(); i < n; i++)
1544 SMESH::Filter::Criterion aCriterion = SMESHGUI_FilterDlg::createCriterion();
1545 theTable->GetCriterion(i, aCriterion);
1546 AddCriterion(aCriterion);
1550 //=======================================================================
1551 // name : SMESHGUI_FilterTable::CurrentCell
1552 // Purpose : Returns current cell
1553 //=======================================================================
1554 bool SMESHGUI_FilterTable::CurrentCell (int& theRow, int& theCol) const
1556 theRow = myTables[ GetType() ]->currentRow();
1557 theCol = myTables[ GetType() ]->currentColumn();
1558 return theRow >= 0 && theCol >= 0;
1561 //=======================================================================
1562 // name : SMESHGUI_FilterTable::SetText
1563 // Purpose : Set text and internal value in cell of threshold value
1564 //=======================================================================
1565 void SMESHGUI_FilterTable::SetThreshold (const int theRow,
1566 const QString& theText,
1567 const int theEntityType)
1569 Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ];
1570 aTable->setText(theRow, 2, theText);
1573 //=======================================================================
1574 // name : SMESHGUI_FilterTable::SetText
1575 // Purpose : Get text and internal value from cell of threshold value
1576 //=======================================================================
1577 bool SMESHGUI_FilterTable::GetThreshold (const int theRow,
1579 const int theEntityType)
1581 Table* aTable = myTables[ theEntityType == -1 ? GetType() : theEntityType ];
1582 QTableItem* anItem = aTable->item(theRow, 2);
1585 theText = anItem->text();
1593 Class : SMESHGUI_FilterDlg
1594 Description : Dialog to specify filters for VTK viewer
1598 //=======================================================================
1599 // name : SMESHGUI_FilterDlg::SMESHGUI_FilterDlg
1600 // Purpose : Constructor
1601 //=======================================================================
1602 SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule,
1603 const QValueList<int>& theTypes,
1604 const char* theName)
1605 : QDialog( SMESH::GetDesktop( theModule ), theName, false,
1606 WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu),
1607 mySMESHGUI( theModule ),
1608 mySelectionMgr( SMESH::GetSelectionMgr( theModule ) )
1610 if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
1611 mySelector = aViewWindow->GetSelector();
1613 construct(theTypes);
1616 //=======================================================================
1617 // name : SMESHGUI_FilterDlg::SMESHGUI_FilterDlg
1618 // Purpose : Constructor
1619 //=======================================================================
1620 SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( SMESHGUI* theModule,
1622 const char* theName)
1623 : QDialog( SMESH::GetDesktop( theModule ), theName, false,
1624 WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu),
1625 mySMESHGUI( theModule ),
1626 mySelectionMgr( SMESH::GetSelectionMgr( theModule ) )
1628 if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
1629 mySelector = aViewWindow->GetSelector();
1630 QValueList<int> aTypes;
1631 aTypes.append(theType);
1635 //=======================================================================
1636 // name : SMESHGUI_FilterDlg::construct
1637 // Purpose : Construct dialog (called by constructor)
1638 //=======================================================================
1639 void SMESHGUI_FilterDlg::construct (const QValueList<int>& theTypes)
1643 setCaption(tr("CAPTION"));
1645 QVBoxLayout* aDlgLay = new QVBoxLayout (this, MARGIN, SPACING);
1647 myMainFrame = createMainFrame (this);
1648 QFrame* aBtnFrame = createButtonFrame(this);
1650 aDlgLay->addWidget(myMainFrame);
1651 aDlgLay->addWidget(aBtnFrame);
1653 aDlgLay->setStretchFactor(myMainFrame, 1);
1658 //=======================================================================
1659 // name : SMESHGUI_FilterDlg::createMainFrame
1660 // Purpose : Create frame containing dialog's input fields
1661 //=======================================================================
1662 QFrame* SMESHGUI_FilterDlg::createMainFrame (QWidget* theParent)
1664 QGroupBox* aMainFrame = new QGroupBox(1, Qt::Horizontal, theParent);
1665 aMainFrame->setFrameStyle(QFrame::NoFrame);
1666 aMainFrame->setInsideMargin(0);
1670 myTable = new SMESHGUI_FilterTable( mySMESHGUI, aMainFrame, myTypes );
1671 myTable->SetLibsEnabled(true);
1673 QFrame* aLine = new QFrame(myTable->GetTableGrp());
1674 aLine->setFrameStyle(QFrame::HLine | QFrame::Sunken);
1676 mySetInViewer = new QCheckBox(tr("SET_IN_VIEWER"), myTable->GetTableGrp());
1677 mySetInViewer->setChecked(true);
1680 mySourceGrp = createSourceGroup(aMainFrame);
1682 connect(myTable, SIGNAL(CriterionChanged(const int, const int)),
1683 SLOT(onCriterionChanged(const int, const int)));
1685 connect(myTable, SIGNAL(CurrentChanged(int, int)),
1686 SLOT(onCurrentChanged(int, int)));
1691 //=======================================================================
1692 // name : SMESHGUI_FilterDlg::createSourceFrame
1693 // Purpose : Create frame containing source radio button
1694 //=======================================================================
1695 QButtonGroup* SMESHGUI_FilterDlg::createSourceGroup (QWidget* theParent)
1697 QButtonGroup* aGrp = new QButtonGroup(1, Qt::Vertical, tr("SOURCE"), theParent);
1699 QRadioButton* aMeshBtn = new QRadioButton(tr("MESH"), aGrp);
1700 QRadioButton* aSelBtn = new QRadioButton(tr("SELECTION"), aGrp);
1701 QRadioButton* aGrpBtn = new QRadioButton(tr("CURRENT_GROUP"), aGrp);
1703 aGrp->insert(aMeshBtn, Mesh);
1704 aGrp->insert(aSelBtn, Selection);
1705 aGrp->insert(aGrpBtn, Dialog);
1707 aGrp->setButton(Selection);
1712 //=======================================================================
1713 // name : SMESHGUI_FilterDlg::updateMainButtons
1714 // Purpose : Update visibility of main buttons (OK, Cancel, Close ...)
1715 //=======================================================================
1716 void SMESHGUI_FilterDlg::updateMainButtons()
1718 if (myTypes.count() == 1)
1720 myButtons[ BTN_Cancel ]->show();
1721 myButtons[ BTN_Apply ]->hide();
1722 myButtons[ BTN_Close ]->hide();
1726 myButtons[ BTN_Cancel ]->hide();
1727 myButtons[ BTN_Apply ]->show();
1728 myButtons[ BTN_Close ]->show();
1731 // updateGeometry();
1734 //=======================================================================
1735 // name : SMESHGUI_FilterDlg::createButtonFrame
1736 // Purpose : Create frame containing buttons
1737 //=======================================================================
1738 QFrame* SMESHGUI_FilterDlg::createButtonFrame (QWidget* theParent)
1740 QGroupBox* aGrp = new QGroupBox(1, Qt::Vertical, theParent);
1742 myButtons[ BTN_OK ] = new QPushButton(tr("SMESH_BUT_OK" ), aGrp);
1743 myButtons[ BTN_Apply ] = new QPushButton(tr("SMESH_BUT_APPLY"), aGrp);
1745 QLabel* aLbl = new QLabel(aGrp);
1746 aLbl->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
1748 myButtons[ BTN_Cancel ] = new QPushButton(tr("SMESH_BUT_CANCEL"), aGrp);
1749 myButtons[ BTN_Close ] = new QPushButton(tr("SMESH_BUT_CLOSE"), aGrp);
1751 connect(myButtons[ BTN_OK ], SIGNAL(clicked()), SLOT(onOk()));
1752 connect(myButtons[ BTN_Cancel ], SIGNAL(clicked()), SLOT(onClose()));
1753 connect(myButtons[ BTN_Close ], SIGNAL(clicked()), SLOT(onClose()));
1754 connect(myButtons[ BTN_Apply ], SIGNAL(clicked()), SLOT(onApply()));
1756 updateMainButtons();
1761 //=======================================================================
1762 // name : SMESHGUI_FilterDlg::~SMESHGUI_FilterDlg
1763 // Purpose : Destructor
1764 //=======================================================================
1765 SMESHGUI_FilterDlg::~SMESHGUI_FilterDlg()
1769 //=======================================================================
1770 // name : SMESHGUI_FilterDlg::Init
1771 // Purpose : Init dialog fields, connect signals and slots, show dialog
1772 //=======================================================================
1773 void SMESHGUI_FilterDlg::Init (const int type)
1775 QValueList<int> aTypes;
1776 aTypes.append(type);
1780 //=======================================================================
1781 // name : SMESHGUI_FilterDlg::Init
1782 // Purpose : Init dialog fields, connect signals and slots, show dialog
1783 //=======================================================================
1784 void SMESHGUI_FilterDlg::Init (const QValueList<int>& theTypes)
1788 myMesh = SMESH::SMESH_Mesh::_nil();
1790 myIsSelectionChanged = false;
1792 myTable->Init(theTypes);
1795 if (theTypes.count() == 1)
1797 int aType = theTypes.first();
1798 if (aType == SMESH::NODE ) setCaption(tr("NODES_TLT"));
1799 else if (aType == SMESH::EDGE ) setCaption(tr("EDGES_TLT"));
1800 else if (aType == SMESH::FACE ) setCaption(tr("FACES_TLT"));
1801 else if (aType == SMESH::VOLUME) setCaption(tr("VOLUMES_TLT"));
1804 setCaption(tr("TLT"));
1806 qApp->processEvents();
1811 mySMESHGUI->SetActiveDialogBox((QDialog*)this);
1813 connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), SLOT(onDeactivate()));
1814 connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), SLOT(onClose()));
1817 mySMESHGUI->DefineDlgPosition(this, x, y);
1820 updateMainButtons();
1823 // Initialise filter table with values of previous filter
1824 QValueList<int>::const_iterator anIter;
1825 for (anIter = theTypes.begin(); anIter != theTypes.end(); ++anIter)
1827 myTable->Clear(*anIter);
1828 if (!myFilter[ *anIter ]->_is_nil())
1830 SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria;
1831 if (myFilter[ *anIter ]->GetCriteria(aCriteria))
1833 for (int i = 0, n = aCriteria->length(); i < n; i++)
1834 myTable->AddCriterion(aCriteria[ i ], *anIter);
1839 if (myInsertState.contains(theTypes.first()))
1840 mySetInViewer->setChecked(myInsertState[ theTypes.first() ]);
1842 mySetInViewer->setChecked(true);
1843 if (myApplyToState.contains(theTypes.first()))
1844 mySourceGrp->setButton(myApplyToState[ theTypes.first() ]);
1846 mySourceGrp->setButton(Selection);
1849 //=======================================================================
1850 // name : SMESHGUI_FilterDlg::onOk
1851 // Purpose : SLOT called when "Ok" button pressed.
1852 // Assign filters VTK viewer and close dialog
1853 //=======================================================================
1854 void SMESHGUI_FilterDlg::onOk()
1858 mySelectionMgr->clearFilters();
1859 disconnect(mySMESHGUI, 0, this, 0);
1860 disconnect(mySelectionMgr, 0, this, 0);
1861 mySMESHGUI->ResetState();
1867 //=======================================================================
1868 // name : SMESHGUI_FilterDlg::onClose
1869 // Purpose : SLOT called when "Close" button pressed. Close dialog
1870 //=======================================================================
1871 void SMESHGUI_FilterDlg::onClose()
1873 // Restore previously selected object
1876 SALOME_ListIO aList;
1877 mySelectionMgr->clearFilters();
1878 mySelectionMgr->clearSelected();
1879 SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter (myIObjects);
1880 for (; anIter.More(); anIter.Next())
1882 aList.Append(anIter.Key());
1884 TColStd_MapOfInteger aResMap;
1885 const TColStd_IndexedMapOfInteger& anIndMap = anIter.Value();
1886 for (int i = 1, n = anIndMap.Extent(); i <= n; i++)
1887 aResMap.Add(anIndMap(i));
1889 mySelector->AddOrRemoveIndex( anIter.Key(), aResMap, false);
1890 if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
1891 aViewWindow->highlight( anIter.Key(), true, true );
1893 mySelectionMgr->setSelectedObjects(aList, false);
1896 disconnect(mySMESHGUI, 0, this, 0);
1897 disconnect(mySelectionMgr, 0, this, 0);
1898 mySMESHGUI->ResetState();
1903 //=======================================================================
1904 // name : SMESHGUI_FilterDlg::onDeactivate
1905 // Purpose : SLOT called when dialog must be deativated
1906 //=======================================================================
1907 void SMESHGUI_FilterDlg::onDeactivate()
1912 //=======================================================================
1913 // name : SMESHGUI_FilterDlg::enterEvent
1914 // Purpose : Event filter
1915 //=======================================================================
1916 void SMESHGUI_FilterDlg::enterEvent (QEvent*)
1918 // mySMESHGUI->EmitSignalDeactivateDialog();
1919 mySMESHGUI->SetActiveDialogBox((QDialog*)this);
1920 mySMESHGUI->ResetState();
1924 //=======================================================================
1925 // name : closeEvent()
1927 //=======================================================================
1928 void SMESHGUI_FilterDlg::closeEvent (QCloseEvent*)
1933 //=======================================================================
1934 // name : SMESHGUI_FilterDlg::getIdsFromWg
1935 // Purpose : Retrieve list of ids from given widget
1936 //=======================================================================
1937 void SMESHGUI_FilterDlg::getIdsFromWg (const QWidget* theWg, QValueList<int>& theRes) const
1943 if (theWg->inherits("QListBox"))
1945 QListBox* aListBox = (QListBox*)theWg;
1947 for (int i = 0, n = aListBox->count(); i < n; i++)
1949 int anId = aListBox->text(i).toInt(&b);
1951 theRes.append(anId);
1954 else if (theWg->inherits("QLineEdit"))
1956 QLineEdit* aLineEdit = (QLineEdit*)theWg;
1957 QString aStr = aLineEdit->text();
1958 QRegExp aRegExp("(\\d+)");
1963 aPos = aRegExp.search(aStr, aPos);
1966 int anId = aRegExp.cap(1).toInt(&b);
1968 theRes.append(anId);
1969 aPos += aRegExp.matchedLength();
1975 //=======================================================================
1976 // name : SMESHGUI_FilterDlg::getSelMode
1977 // Purpose : Get selection mode of specified type
1978 //=======================================================================
1979 Selection_Mode SMESHGUI_FilterDlg::getSelMode (const int theType) const
1983 case SMESH::NODE : return NodeSelection;
1984 case SMESH::EDGE : return EdgeSelection;
1985 case SMESH::FACE : return FaceSelection;
1986 case SMESH::VOLUME : return VolumeSelection;
1987 default : return ActorSelection;
1992 //=======================================================================
1993 // name : SMESHGUI_FilterDlg::setIdsToWg
1994 // Purpose : Insert identifiers in specified widgets
1995 //=======================================================================
1996 void SMESHGUI_FilterDlg::setIdsToWg (QWidget* theWg, const QValueList<int>& theIds)
2001 if (theWg->inherits("QListBox"))
2003 QListBox* aListBox = (QListBox*)theWg;
2006 QStringList aStrList;
2007 QValueList<int>::const_iterator anIter;
2008 for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter)
2009 aStrList.append(QString("%1").arg(*anIter));
2011 aListBox->insertStringList(aStrList);
2013 else if (theWg->inherits("QLineEdit"))
2015 QLineEdit* aLineEdit = (QLineEdit*)theWg;
2017 QValueList<int>::const_iterator anIter;
2019 for (anIter = theIds.begin(); anIter != theIds.end(); ++ anIter)
2020 aStr += QString("%1 ").arg(*anIter);
2022 if (!aStr.isEmpty())
2023 aStr.remove(aStr.length() - 1, 1);
2025 aLineEdit->setText(aStr);
2029 //=======================================================================
2030 // name : SMESHGUI_FilterDlg::isValid
2031 // Purpose : Verify validity of input data
2032 //=======================================================================
2033 bool SMESHGUI_FilterDlg::isValid() const
2035 if (!myTable->IsValid())
2038 for (int i = 0, n = myTable->NumRows(); i < n; i++)
2040 int aType = myTable->GetCriterionType(i);
2041 if (aType == FT_BelongToGeom ||
2042 aType == FT_BelongToPlane ||
2043 aType == FT_BelongToCylinder ||
2044 aType == FT_LyingOnGeom) {
2046 myTable->GetThreshold(i, aName);
2048 std::vector<_PTR(SObject)> aList =
2049 SMESH::GetActiveStudyDocument()->FindObjectByName(aName.latin1(), "GEOM");
2050 if (aList.size() == 0) {
2051 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2052 tr("BAD_SHAPE_NAME").arg(aName), QMessageBox::Ok);
2056 if (aType == FT_BelongToCylinder || aType == FT_BelongToPlane) {
2057 CORBA::Object_var anObject = SMESH::SObjectToObject(aList[ 0 ]);
2058 //GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(aList[ 0 ]->GetObject());
2059 GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(anObject);
2060 if (!aGeomObj->_is_nil()) {
2062 if (!GEOMBase::GetShape(aGeomObj, aFace) ||
2064 aFace.ShapeType() != TopAbs_FACE) {
2065 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2066 tr("SHAPE_IS_NOT_A_FACE").arg(aName), QMessageBox::Ok);
2070 Handle(Geom_Surface) aSurf = BRep_Tool::Surface(TopoDS::Face(aFace));
2071 if (aSurf.IsNull()) {
2072 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2073 tr("SHAPE_IS_NOT_A_FACE").arg(aName), QMessageBox::Ok);
2077 if (aType == FT_BelongToPlane && !aSurf->IsKind(STANDARD_TYPE(Geom_Plane))) {
2078 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2079 tr("SHAPE_IS_NOT_A_PLANE").arg(aName), QMessageBox::Ok);
2083 if (aType == FT_BelongToCylinder && !aSurf->IsKind(STANDARD_TYPE(Geom_CylindricalSurface))) {
2084 QMessageBox::information(SMESHGUI::desktop(), tr("SMESH_INSUFFICIENT_DATA"),
2085 tr("SHAPE_IS_NOT_A_CYLINDER").arg(aName), QMessageBox::Ok);
2096 //=======================================================================
2097 // name : SMESHGUI_FilterDlg::SetSourceWg
2098 // Purpose : Set widget of parent dialog containing idsto be filtered if
2099 // user select corresponding source radio button
2100 //=======================================================================
2101 void SMESHGUI_FilterDlg::SetSourceWg (QWidget* theWg)
2106 //=======================================================================
2107 // name : SMESHGUI_FilterDlg::SetGroupIds
2108 // Purpose : Set mesh
2109 //=======================================================================
2110 void SMESHGUI_FilterDlg::SetMesh (SMESH::SMESH_Mesh_ptr theMesh)
2115 //=======================================================================
2116 // name : SMESHGUI_FilterDlg::SetSelection
2117 // Purpose : Get filtered ids
2118 //=======================================================================
2119 void SMESHGUI_FilterDlg::SetSelection()
2122 disconnect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(onSelectionDone()));
2124 if (mySelectionMgr) {
2126 const SALOME_ListIO& anObjs = mySelector->StoredIObjects();
2127 SALOME_ListIteratorOfListIO anIter (anObjs);
2128 for (; anIter.More(); anIter.Next()) {
2129 TColStd_IndexedMapOfInteger aMap;
2130 mySelector->GetIndex(anIter.Value(), aMap);
2131 myIObjects.Bind(anIter.Value(), aMap);
2134 connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(onSelectionDone()));
2142 //=======================================================================
2143 // name : SMESHGUI_FilterDlg::onApply
2144 // Purpose : SLOT called when "Apply" button pressed.
2145 // Assign filters to VTK viewer
2146 //=======================================================================
2147 bool SMESHGUI_FilterDlg::onApply()
2153 int aCurrType = myTable->GetType();
2155 if (!createFilter(aCurrType))
2158 insertFilterInViewer();
2160 if (!myFilter[ aCurrType ]->GetPredicate()->_is_nil()) {
2161 QValueList<int> aResultIds;
2162 filterSource(aCurrType, aResultIds);
2163 selectInViewer(aCurrType, aResultIds);
2166 myInsertState[ aCurrType ] = mySetInViewer->isChecked();
2167 myApplyToState[ aCurrType ] = mySourceGrp->id(mySourceGrp->selected());
2169 catch(const SALOME::SALOME_Exception& S_ex)
2171 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2180 //=======================================================================
2181 // name : SMESHGUI_FilterDlg::createFilter
2182 // Purpose : Create predicate for given type
2183 //=======================================================================
2184 bool SMESHGUI_FilterDlg::createFilter (const int theType)
2186 SMESH::FilterManager_var aFilterMgr = SMESH::GetFilterManager();
2187 if (aFilterMgr->_is_nil())
2190 int n = myTable->NumRows();
2192 SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria;
2193 aCriteria->length(n);
2195 long aPrecision = -1;
2196 SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( mySMESHGUI );
2198 if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
2199 aPrecision = mgr->integerValue( "SMESH", "controls_precision", aPrecision );
2201 for (CORBA::ULong i = 0; i < n; i++) {
2202 SMESH::Filter::Criterion aCriterion = createCriterion();
2203 myTable->GetCriterion(i, aCriterion);
2204 aCriterion.Precision = aPrecision;
2205 aCriteria[ i ] = aCriterion;
2208 myFilter[ theType ] = aFilterMgr->CreateFilter();
2209 myFilter[ theType ]->SetCriteria(aCriteria.inout());
2214 //=======================================================================
2215 // name : SMESHGUI_FilterDlg::insertFilterInViewer
2216 // Purpose : Insert filter in viewer
2217 //=======================================================================
2218 void SMESHGUI_FilterDlg::insertFilterInViewer()
2220 if (SVTK_InteractorStyle* aStyle = SMESH::GetInteractorStyle()) {
2221 SMESH::ElementType anEntType = (SMESH::ElementType)myTable->GetType();
2223 if (myFilter[ myTable->GetType() ]->_is_nil() ||
2224 myFilter[ myTable->GetType() ]->GetPredicate()->_is_nil() ||
2225 !mySetInViewer->isChecked()) {
2226 SMESH::RemoveFilter(getFilterId(anEntType), aStyle);
2228 Handle(SMESHGUI_PredicateFilter) aFilter = new SMESHGUI_PredicateFilter();
2229 aFilter->SetPredicate(myFilter[ myTable->GetType() ]->GetPredicate());
2230 SMESH::SetFilter(aFilter, aStyle);
2235 //=======================================================================
2236 // name : SMESHGUI_FilterDlg::filterSource
2237 // Purpose : Filter source ids
2238 //=======================================================================
2239 void SMESHGUI_FilterDlg::filterSource (const int theType,
2240 QValueList<int>& theResIds)
2243 if (myFilter[ theType ]->_is_nil())
2246 int aSourceId = mySourceGrp->id(mySourceGrp->selected());
2248 if (aSourceId == Mesh)
2250 if (myMesh->_is_nil())
2252 SMESH::long_array_var anIds = myFilter[ theType ]->GetElementsId(myMesh);
2253 for (int i = 0, n = anIds->length(); i < n; i++)
2254 theResIds.append(anIds[ i ]);
2256 else if (aSourceId == Selection)
2258 filterSelectionSource(theType, theResIds);
2260 else if (aSourceId == Dialog)
2262 // retrieve ids from dialog
2263 QValueList<int> aDialogIds;
2264 getIdsFromWg(mySourceWg, aDialogIds);
2266 if (myMesh->_is_nil())
2268 theResIds = aDialogIds;
2273 SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate();
2274 aPred->SetMesh(myMesh);
2275 QValueList<int>::const_iterator anIter;
2276 for (anIter = aDialogIds.begin(); anIter != aDialogIds.end(); ++ anIter)
2277 if (aPred->IsSatisfy(*anIter))
2278 theResIds.append(*anIter);
2280 // set ids to the dialog
2281 setIdsToWg(mySourceWg, theResIds);
2285 //=======================================================================
2286 // name : SMESHGUI_FilterDlg::filterSelectionSource
2287 // Purpose : Filter source selection
2288 //=======================================================================
2289 void SMESHGUI_FilterDlg::filterSelectionSource (const int theType,
2290 QValueList<int>& theResIds)
2293 if (myMesh->_is_nil() || mySelectionMgr == 0)
2296 // Create map of entities to be filtered
2297 TColStd_MapOfInteger aToBeFiltered;
2298 SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger anIter(myIObjects);
2300 for (; anIter.More(); anIter.Next())
2303 SMESH::SMESH_subMesh_var aSubMesh = SMESH::IObjectToInterface<SMESH::SMESH_subMesh>(anIter.Key());
2304 if (!aSubMesh->_is_nil())
2306 if (aSubMesh->GetFather()->GetId() == myMesh->GetId())
2308 SMESH::long_array_var anIds =
2309 theType == SMESH::NODE ? aSubMesh->GetNodesId() : aSubMesh->GetElementsId();
2310 for (int i = 0, n = anIds->length(); i < n; i++)
2311 aToBeFiltered.Add(anIds[ i ]);
2316 SMESH::SMESH_GroupBase_var aGroup =
2317 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(anIter.Key());
2318 if (!aGroup->_is_nil())
2320 if (aGroup->GetType() == theType && aGroup->GetMesh()->GetId() == myMesh->GetId())
2322 SMESH::long_array_var anIds = aGroup->GetListOfID();
2323 for (int i = 0, n = anIds->length(); i < n; i++)
2324 aToBeFiltered.Add(anIds[ i ]);
2329 SMESH::SMESH_Mesh_var aMeshPtr = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIter.Key());
2330 if (!aMeshPtr->_is_nil() && aMeshPtr->GetId() == myMesh->GetId())
2332 const TColStd_IndexedMapOfInteger& aSelMap = anIter.Value();
2334 if (aSelMap.Extent() > 0)
2336 if(SMESH::FindActorByEntry(anIter.Key()->getEntry()))
2338 for (int i = 1; i <= aSelMap.Extent(); i++)
2339 aToBeFiltered.Add(aSelMap(i));
2346 SMESH::Predicate_ptr aPred = myFilter[ theType ]->GetPredicate();
2347 aPred->SetMesh(myMesh);
2348 TColStd_MapIteratorOfMapOfInteger aResIter(aToBeFiltered);
2349 for (; aResIter.More(); aResIter.Next())
2350 if (aPred->IsSatisfy(aResIter.Key()))
2351 theResIds.append(aResIter.Key());
2354 //=======================================================================
2355 // name : SMESHGUI_FilterDlg::selectInViewer
2356 // Purpose : Select given entities in viewer
2357 //=======================================================================
2358 void SMESHGUI_FilterDlg::selectInViewer (const int theType, const QValueList<int>& theIds)
2360 if (mySelectionMgr == 0 || myMesh->_is_nil())
2363 mySelectionMgr->clearFilters();
2365 // Set new selection mode if necessary
2366 Selection_Mode aSelMode = getSelMode(theType);
2367 SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );
2368 if ( aViewWindow && aViewWindow->SelectionMode()!=aSelMode) {
2369 mySelectionMgr->clearSelected();
2370 mySelectionMgr->clearFilters();
2371 if (aSelMode == NodeSelection)
2372 SMESH::SetPointRepresentation(true);
2373 aViewWindow->SetSelectionMode(aSelMode);
2377 SMESH_Actor* anActor = SMESH::FindActorByObject(myMesh);
2378 if (!anActor || !anActor->hasIO())
2381 Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
2382 //mySelectionMgr->clearSelected();
2383 //mySelectionMgr->AddIObject(anIO, false);
2384 SALOME_ListIO aList;
2386 mySelectionMgr->setSelectedObjects(aList, false);
2388 // Remove filter corresponding to the current type from viewer
2389 int aType = myTable->GetType();
2390 int aFilterId = SMESHGUI_UnknownFilter;
2391 if (aType == SMESH::EDGE ) aFilterId = SMESHGUI_EdgeFilter;
2392 else if (aType == SMESH::FACE ) aFilterId = SMESHGUI_FaceFilter;
2393 else if (aType == SMESH::VOLUME) aFilterId = SMESHGUI_VolumeFilter;
2394 Handle(VTKViewer_Filter) aFilter = SMESH::GetFilter(aFilterId);
2395 SMESH::RemoveFilter(aFilterId);
2398 TColStd_MapOfInteger aMap;
2399 QValueList<int>::const_iterator anIter;
2400 for (anIter = theIds.begin(); anIter != theIds.end(); ++anIter) {
2404 // Set new selection
2405 mySelector->AddOrRemoveIndex(anIO, aMap, false);
2406 if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
2407 aViewWindow->highlight( anIO, true, true );
2409 // insert previously stored filter in viewer if necessary
2410 if (!aFilter.IsNull())
2411 SMESH::SetFilter(aFilter);
2414 //=======================================================================
2415 // name : SMESHGUI_FilterDlg::createCriterion
2416 // Purpose : Create criterion structure with default values
2417 //=======================================================================
2418 SMESH::Filter::Criterion SMESHGUI_FilterDlg::createCriterion()
2420 SMESH::Filter::Criterion aCriterion;
2422 aCriterion.Type = FT_Undefined;
2423 aCriterion.Compare = FT_Undefined;
2424 aCriterion.Threshold = 0;
2425 aCriterion.UnaryOp = FT_Undefined;
2426 aCriterion.BinaryOp = FT_Undefined;
2427 aCriterion.ThresholdStr = "";
2428 aCriterion.TypeOfElement = SMESH::ALL;
2433 //=======================================================================
2434 // name : SMESHGUI_FilterDlg::onSelectionDone
2435 // Purpose : SLOT called when selection changed.
2436 // If current cell corresponds to the threshold value of
2437 // BelongToGeom criterion name of selected object is set in this cell
2438 //=======================================================================
2439 void SMESHGUI_FilterDlg::onSelectionDone()
2442 const SALOME_ListIO& aList = mySelector->StoredIObjects();
2444 if (aList.Extent() != 1 ||
2445 !myTable->CurrentCell(aRow, aCol) ||
2446 myTable->GetCriterionType(aRow) != FT_BelongToGeom &&
2447 myTable->GetCriterionType(aRow) != FT_BelongToPlane &&
2448 myTable->GetCriterionType(aRow) != FT_BelongToCylinder &&
2449 myTable->GetCriterionType(aRow) != FT_LyingOnGeom)
2452 Handle(SALOME_InteractiveObject) anIO = aList.First();
2453 GEOM::GEOM_Object_var anObj = SMESH::IObjectToInterface<GEOM::GEOM_Object>(anIO);
2454 if (!anObj->_is_nil())
2455 myTable->SetThreshold(aRow, GEOMBase::GetName(anObj));
2458 //=======================================================================
2459 // name : SMESHGUI_FilterDlg::onCriterionChanged
2460 // Purpose : SLOT called when cretarion of current row changed. Update selection
2461 //=======================================================================
2462 void SMESHGUI_FilterDlg::onCriterionChanged (const int , const int)
2467 //=======================================================================
2468 // name : SMESHGUI_FilterDlg::onCurrentChanged
2469 // Purpose : SLOT called when current row changed. Update selection
2470 //=======================================================================
2471 void SMESHGUI_FilterDlg::onCurrentChanged (int, int)
2476 //=======================================================================
2477 // name : SMESHGUI_FilterDlg::updateSelection
2478 // Purpose : UpdateSelection in accordance with current row
2479 //=======================================================================
2480 void SMESHGUI_FilterDlg::updateSelection()
2482 if (mySelectionMgr == 0)
2485 TColStd_MapOfInteger allTypes;
2486 for( int i=0; i<10; i++ )
2488 SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( mySMESHGUI->application()->activeStudy() );
2493 mySelectionMgr->clearFilters();
2497 if (myTable->CurrentCell(aRow, aCol) &&
2498 (myTable->GetCriterionType(aRow) == FT_BelongToGeom ||
2499 myTable->GetCriterionType(aRow) == FT_BelongToPlane ||
2500 myTable->GetCriterionType(aRow) == FT_BelongToCylinder ||
2501 myTable->GetCriterionType(aRow) == FT_LyingOnGeom)) {
2503 if (myTable->GetCriterionType(aRow) == FT_BelongToGeom ||
2504 myTable->GetCriterionType(aRow) == FT_LyingOnGeom) {
2506 mySelectionMgr->installFilter(new GEOM_SelectionFilter( aStudy, true ));
2508 } else if (myTable->GetCriterionType(aRow) == FT_BelongToPlane) {
2509 mySelectionMgr->installFilter(new GEOM_FaceFilter( aStudy, StdSelect_Plane ) );
2511 } else if (myTable->GetCriterionType(aRow) == FT_BelongToCylinder) {
2512 mySelectionMgr->installFilter(new GEOM_FaceFilter( aStudy, StdSelect_Cylinder ) );
2514 myIsSelectionChanged = true;
2517 if (myIsSelectionChanged) {
2518 mySelectionMgr->installFilter( new GEOM_TypeFilter( aStudy, -1 ) ); // This filter deactivates selection