-// SMESH SMESHGUI : GUI for SMESH component
+// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// SMESH SMESHGUI : GUI for SMESH component
+// File : SMESHGUI_ExtrusionAlongPathDlg.cxx
+// Author : Vadim SANDLER, Open CASCADE S.A.S.
+// SMESH includes
//
-// File : SMESHGUI_ExtrusionAlongPathDlg.cxx
-// Author : Vadim SANDLER
-// Module : SMESH
-// $Header:
-
#include "SMESHGUI_ExtrusionAlongPathDlg.h"
+
#include "SMESHGUI.h"
-#include "SMESHGUI_SpinBox.h"
#include "SMESHGUI_Utils.h"
#include "SMESHGUI_VTKUtils.h"
#include "SMESHGUI_MeshUtils.h"
+#include "SMESHGUI_SpinBox.h"
#include "SMESHGUI_IdValidator.h"
-#include "SMESH_Actor.h"
-#include "SMESH_NumberFilter.hxx"
-#include "SMDS_Mesh.hxx"
-#include "GEOM_ShapeTypeFilter.hxx"
-#include "GEOMBase.h"
-
-#include "QAD_Application.h"
-#include "QAD_WaitCursor.h"
-#include "QAD_Desktop.h"
-#include "QAD_MessageBox.h"
-#include "utilities.h"
+#include "SMESHGUI_FilterDlg.h"
+
+#include <SMESH_Actor.h>
+#include <SMESH_TypeFilter.hxx>
+#include <SMESH_NumberFilter.hxx>
+#include <SMESH_LogicalFilter.hxx>
+
+#include <SMDS_Mesh.hxx>
+// SALOME GEOM includes
+#include <GEOMBase.h>
+
+// SALOME GUI includes
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_OverrideCursor.h>
+#include <SUIT_Desktop.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_Session.h>
+
+#include <LightApp_Application.h>
+#include <LightApp_SelectionMgr.h>
+
+#include <SVTK_ViewWindow.h>
+
+// OCCT includes
#include <BRep_Tool.hxx>
-#include <TopoDS_Shape.hxx>
-#include <TopoDS.hxx>
#include <TopoDS_Vertex.hxx>
#include <gp_Pnt.hxx>
-
-// QT Includes
-#include <qapplication.h>
-#include <qbuttongroup.h>
-#include <qgroupbox.h>
-#include <qlabel.h>
-#include <qlineedit.h>
-#include <qpushbutton.h>
-#include <qtoolbutton.h>
-#include <qradiobutton.h>
-#include <qcheckbox.h>
-#include <qlistbox.h>
-#include <qlayout.h>
-#include <qvalidator.h>
-#include <qptrlist.h>
-
-// IDL Headers
-#include "SALOMEconfig.h"
+#include <TColStd_MapOfInteger.hxx>
+
+// Qt includes
+#include <QButtonGroup>
+#include <QGroupBox>
+#include <QLabel>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QToolButton>
+#include <QRadioButton>
+#include <QCheckBox>
+#include <QListWidget>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QGridLayout>
+#include <QKeyEvent>
+
+// IDL includes
+#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Group)
+#include CORBA_SERVER_HEADER(SMESH_MeshEditor)
-using namespace std;
+#define SPACING 6
+#define MARGIN 11
+
+class SMESHGUI_ExtrusionAlongPathDlg::SetBusy
+{
+public:
+ SetBusy( SMESHGUI_ExtrusionAlongPathDlg* _dlg )
+ {
+ myDlg = _dlg;
+ myDlg->myBusy = true;
+ }
+
+ ~SetBusy()
+ {
+ myDlg->myBusy = false;
+ }
+
+private:
+ SMESHGUI_ExtrusionAlongPathDlg* myDlg;
+};
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::SMESHGUI_ExtrusionAlongPathDlg()
+// function : SMESHGUI_ExtrusionAlongPathDlg()
// purpose : constructor
//=================================================================================
-SMESHGUI_ExtrusionAlongPathDlg::SMESHGUI_ExtrusionAlongPathDlg( QWidget* parent, SALOME_Selection* Sel, bool modal )
- : QDialog( parent, "SMESHGUI_ExtrusionAlongPathDlg", modal,
- WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | Qt::WDestructiveClose )
+SMESHGUI_ExtrusionAlongPathDlg::SMESHGUI_ExtrusionAlongPathDlg( SMESHGUI* theModule )
+ : QDialog( SMESH::GetDesktop( theModule ) ),
+ mySMESHGUI( theModule ),
+ mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ),
+ myFilterDlg( 0 )
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::SMESHGUI_ExtrusionAlongPathDlg");
+ SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( mySMESHGUI );
+ QPixmap edgeImage ( mgr->loadPixmap("SMESH", tr("ICON_DLG_EDGE")));
+ QPixmap faceImage ( mgr->loadPixmap("SMESH", tr("ICON_DLG_TRIANGLE")));
+ QPixmap selectImage ( mgr->loadPixmap("SMESH", tr("ICON_SELECT")));
+ QPixmap addImage ( mgr->loadPixmap("SMESH", tr("ICON_APPEND")));
+ QPixmap removeImage ( mgr->loadPixmap("SMESH", tr("ICON_REMOVE")));
+
myType = -1;
- QPixmap edgeImage ( QAD_Desktop::getResourceManager()->loadPixmap( "SMESH", tr( "ICON_DLG_EDGE" ) ) );
- QPixmap faceImage ( QAD_Desktop::getResourceManager()->loadPixmap( "SMESH", tr( "ICON_DLG_TRIANGLE" ) ) );
- QPixmap selectImage( QAD_Desktop::getResourceManager()->loadPixmap( "SMESH", tr( "ICON_SELECT" ) ) );
- QPixmap addImage ( QAD_Desktop::getResourceManager()->loadPixmap( "SMESH", tr( "ICON_APPEND" ) ) );
- QPixmap removeImage( QAD_Desktop::getResourceManager()->loadPixmap( "SMESH", tr( "ICON_REMOVE" ) ) );
- setCaption( tr( "EXTRUSION_ALONG_PATH" ) );
- setSizeGripEnabled( TRUE );
+ setModal( false );
+ setAttribute( Qt::WA_DeleteOnClose, true );
+ setWindowTitle(tr("EXTRUSION_ALONG_PATH"));
+ setSizeGripEnabled(true);
- QGridLayout* topLayout = new QGridLayout( this );
- topLayout->setSpacing( 6 ); topLayout->setMargin( 11 );
+ QVBoxLayout* topLayout = new QVBoxLayout(this);
+ topLayout->setSpacing(SPACING);
+ topLayout->setMargin(MARGIN);
/***************************************************************/
// Elements type group box (1d / 2d elements)
- ElementsTypeGrp = new QButtonGroup( tr( "SMESH_EXTRUSION" ), this );
- ElementsTypeGrp->setColumnLayout( 0, Qt::Vertical );
- ElementsTypeGrp->layout()->setSpacing( 0 ); ElementsTypeGrp->layout()->setMargin( 0 );
- QGridLayout* ElementsTypeGrpLayout = new QGridLayout( ElementsTypeGrp->layout() );
- ElementsTypeGrpLayout->setAlignment( Qt::AlignTop );
- ElementsTypeGrpLayout->setSpacing( 6 ); ElementsTypeGrpLayout->setMargin( 11 );
-
- Elements1dRB = new QRadioButton( ElementsTypeGrp );
- Elements1dRB->setPixmap( edgeImage );
- Elements2dRB = new QRadioButton( ElementsTypeGrp );
- Elements2dRB->setPixmap( faceImage );
- Elements1dRB->setChecked( true );
+ ConstructorsBox = new QGroupBox(tr("SMESH_EXTRUSION"), this);
+ GroupConstructors = new QButtonGroup(this);
+ QHBoxLayout* ConstructorsBoxLayout = new QHBoxLayout(ConstructorsBox);
+ ConstructorsBoxLayout->setSpacing(SPACING); ConstructorsBoxLayout->setMargin(MARGIN);
+
+ Elements1dRB = new QRadioButton(ConstructorsBox);
+ Elements1dRB->setIcon(edgeImage);
+ Elements2dRB = new QRadioButton(ConstructorsBox);
+ Elements2dRB->setIcon(faceImage);
+ Elements1dRB->setChecked(true);
// layouting
- ElementsTypeGrpLayout->addWidget( Elements1dRB, 0, 0 );
- ElementsTypeGrpLayout->addWidget( Elements2dRB, 0, 2 );
-
+ ConstructorsBoxLayout->addWidget(Elements1dRB);
+ ConstructorsBoxLayout->addWidget(Elements2dRB);
+ GroupConstructors->addButton(Elements1dRB, 0);
+ GroupConstructors->addButton(Elements2dRB, 1);
+
/***************************************************************/
// Arguments group box
- ArgumentsGrp = new QGroupBox( tr( "EXTRUSION_1D" ), this );
- ArgumentsGrp->setColumnLayout( 0, Qt::Vertical );
- ArgumentsGrp->layout()->setSpacing( 0 ); ArgumentsGrp->layout()->setMargin( 0 );
- QGridLayout* ArgumentsGrpLayout = new QGridLayout( ArgumentsGrp->layout() );
- ArgumentsGrpLayout->setAlignment( Qt::AlignTop );
- ArgumentsGrpLayout->setSpacing( 6 ); ArgumentsGrpLayout->setMargin( 11 );
+ GroupArguments = new QGroupBox(tr("EXTRUSION_1D"), this);
+ QGridLayout* GroupArgumentsLayout = new QGridLayout(GroupArguments);
+ GroupArgumentsLayout->setSpacing(SPACING); GroupArgumentsLayout->setMargin(MARGIN);
+
+ myIdValidator = new SMESHGUI_IdValidator(this);
// Controls for elements selection
- ElementsLab = new QLabel( tr( "SMESH_ID_ELEMENTS" ), ArgumentsGrp );
+ ElementsLab = new QLabel(tr("SMESH_ID_ELEMENTS"), GroupArguments);
- SelectElementsButton = new QToolButton( ArgumentsGrp );
- SelectElementsButton->setPixmap( selectImage );
+ SelectElementsButton = new QToolButton(GroupArguments);
+ SelectElementsButton->setIcon(selectImage);
- ElementsLineEdit = new QLineEdit( ArgumentsGrp );
- ElementsLineEdit->setValidator( new SMESHGUI_IdValidator( this ) );
+ ElementsLineEdit = new QLineEdit(GroupArguments);
+ ElementsLineEdit->setValidator(myIdValidator);
+ myFilterBtn = new QPushButton( tr( "SMESH_BUT_FILTER" ), GroupArguments );
+ connect(myFilterBtn, SIGNAL(clicked()), this, SLOT(setFilters()));
// Controls for the whole mesh selection
- MeshCheck = new QCheckBox( tr( "SMESH_SELECT_WHOLE_MESH" ), ArgumentsGrp );
+ MeshCheck = new QCheckBox(tr("SMESH_SELECT_WHOLE_MESH"), GroupArguments);
// Controls for path selection
- PathGrp = new QGroupBox( tr( "SMESH_PATH" ), ArgumentsGrp );
- PathGrp->setColumnLayout( 0, Qt::Vertical );
- PathGrp->layout()->setSpacing( 0 ); PathGrp->layout()->setMargin( 0 );
- QGridLayout* PathGrpLayout = new QGridLayout( PathGrp->layout() );
- PathGrpLayout->setAlignment( Qt::AlignTop );
- PathGrpLayout->setSpacing( 6 ); PathGrpLayout->setMargin( 11 );
-
- // Controls for path mesh selection
- PathMeshLab = new QLabel( tr( "SMESH_PATH_MESH" ), PathGrp );
+ PathGrp = new QGroupBox(tr("SMESH_PATH"), GroupArguments);
+ QGridLayout* PathGrpLayout = new QGridLayout(PathGrp);
+ PathGrpLayout->setSpacing(SPACING); PathGrpLayout->setMargin(MARGIN);
- SelectPathMeshButton = new QToolButton( PathGrp );
- SelectPathMeshButton->setPixmap( selectImage );
-
- PathMeshLineEdit = new QLineEdit( PathGrp );
- PathMeshLineEdit->setReadOnly( true );
-
- // Controls for path shape selection
- PathShapeLab = new QLabel( tr( "SMESH_PATH_SHAPE" ), PathGrp );
+ // Controls for path mesh selection
+ QLabel* PathMeshLab = new QLabel(tr("SMESH_PATH_MESH"), PathGrp);
- SelectPathShapeButton = new QToolButton( PathGrp );
- SelectPathShapeButton->setPixmap( selectImage );
+ SelectPathMeshButton = new QToolButton(PathGrp);
+ SelectPathMeshButton->setIcon(selectImage);
- PathShapeLineEdit = new QLineEdit( PathGrp );
- PathShapeLineEdit->setReadOnly( true );
+ PathMeshLineEdit = new QLineEdit(PathGrp);
+ PathMeshLineEdit->setReadOnly(true);
// Controls for path starting point selection
- StartPointLab = new QLabel( tr( "SMESH_PATH_START" ), PathGrp );
+ QLabel* StartPointLab = new QLabel(tr("SMESH_PATH_START"), PathGrp);
- SelectStartPointButton = new QToolButton( PathGrp );
- SelectStartPointButton->setPixmap( selectImage );
+ SelectStartPointButton = new QToolButton(PathGrp);
+ SelectStartPointButton->setIcon(selectImage);
- StartPointLineEdit = new QLineEdit( PathGrp );
- StartPointLineEdit->setValidator( new QIntValidator( this ) );
+ StartPointLineEdit = new QLineEdit(PathGrp);
+ StartPointLineEdit->setValidator(new QIntValidator(this));
// layouting
- PathGrpLayout->addWidget( PathMeshLab, 0, 0 );
- PathGrpLayout->addWidget( SelectPathMeshButton, 0, 1 );
- PathGrpLayout->addWidget( PathMeshLineEdit, 0, 2 );
- PathGrpLayout->addWidget( PathShapeLab, 1, 0 );
- PathGrpLayout->addWidget( SelectPathShapeButton, 1, 1 );
- PathGrpLayout->addWidget( PathShapeLineEdit, 1, 2 );
- PathGrpLayout->addWidget( StartPointLab, 2, 0 );
- PathGrpLayout->addWidget( SelectStartPointButton, 2, 1 );
- PathGrpLayout->addWidget( StartPointLineEdit, 2, 2 );
-
- // Controls for angles defining
- AnglesCheck = new QCheckBox( tr( "SMESH_USE_ANGLES" ), ArgumentsGrp );
-
- AnglesGrp = new QGroupBox( tr( "SMESH_ANGLES" ), ArgumentsGrp );
- AnglesGrp->setColumnLayout( 0, Qt::Vertical );
- AnglesGrp->layout()->setSpacing( 0 ); AnglesGrp->layout()->setMargin( 0 );
- QGridLayout* AnglesGrpLayout = new QGridLayout( AnglesGrp->layout() );
- AnglesGrpLayout->setAlignment( Qt::AlignTop );
- AnglesGrpLayout->setSpacing( 6 ); AnglesGrpLayout->setMargin( 11 );
-
- AnglesList = new QListBox( AnglesGrp );
- AnglesList->setSelectionMode( QListBox::Extended );
+ PathGrpLayout->addWidget(PathMeshLab, 0, 0);
+ PathGrpLayout->addWidget(SelectPathMeshButton, 0, 1);
+ PathGrpLayout->addWidget(PathMeshLineEdit, 0, 2);
+ PathGrpLayout->addWidget(StartPointLab, 1, 0);
+ PathGrpLayout->addWidget(SelectStartPointButton, 1, 1);
+ PathGrpLayout->addWidget(StartPointLineEdit, 1, 2);
+
+ BasePointGrp = new QGroupBox(tr("SMESH_BASE_POINT"), GroupArguments);
+ BasePointGrp->setCheckable(true);
+ BasePointGrp->setChecked(false);
+ QHBoxLayout* BasePointGrpLayout = new QHBoxLayout(BasePointGrp);
+ BasePointGrpLayout->setSpacing(SPACING); BasePointGrpLayout->setMargin(MARGIN);
+
+ SelectBasePointButton = new QToolButton(BasePointGrp);
+ SelectBasePointButton->setIcon(selectImage);
+
+ QLabel* XLab = new QLabel(tr("SMESH_X"), BasePointGrp);
+ XSpin = new SMESHGUI_SpinBox(BasePointGrp);
+ QLabel* YLab = new QLabel(tr("SMESH_Y"), BasePointGrp);
+ YSpin = new SMESHGUI_SpinBox(BasePointGrp);
+ QLabel* ZLab = new QLabel(tr("SMESH_Z"), BasePointGrp);
+ ZSpin = new SMESHGUI_SpinBox(BasePointGrp);
- AddAngleButton = new QToolButton( AnglesGrp );
- AddAngleButton->setPixmap( addImage );
+ // layouting
+ BasePointGrpLayout->addWidget(SelectBasePointButton);
+ BasePointGrpLayout->addWidget(XLab);
+ BasePointGrpLayout->addWidget(XSpin);
+ BasePointGrpLayout->addWidget(YLab);
+ BasePointGrpLayout->addWidget(YSpin);
+ BasePointGrpLayout->addWidget(ZLab);
+ BasePointGrpLayout->addWidget(ZSpin);
- RemoveAngleButton = new QToolButton( AnglesGrp );
- RemoveAngleButton->setPixmap( removeImage );
+ AnglesGrp = new QGroupBox(tr("SMESH_ANGLES"), GroupArguments);
+ AnglesGrp->setCheckable(true);
+ AnglesGrp->setChecked(false);
+ QGridLayout* AnglesGrpLayout = new QGridLayout(AnglesGrp);
+ AnglesGrpLayout->setSpacing(SPACING); AnglesGrpLayout->setMargin(MARGIN);
- AngleSpin = new SMESHGUI_SpinBox( AnglesGrp );
+ AnglesList = new QListWidget(AnglesGrp);
+ AnglesList->setSelectionMode(QListWidget::ExtendedSelection);
- // layouting
- QVBoxLayout* bLayout = new QVBoxLayout();
- bLayout->addWidget( AddAngleButton );
- bLayout->addSpacing( 6 );
- bLayout->addWidget( RemoveAngleButton );
- bLayout->addStretch();
- AnglesGrpLayout->addMultiCellWidget( AnglesList, 0, 1, 0, 0 );
- AnglesGrpLayout->addMultiCellLayout( bLayout, 0, 1, 1, 1 );
- AnglesGrpLayout->addWidget( AngleSpin, 0, 2 );
- AnglesGrpLayout->setRowStretch( 1, 10 );
-
- // Controls for base point defining
- BasePointCheck = new QCheckBox( tr( "SMESH_USE_BASE_POINT" ), ArgumentsGrp );
-
- BasePointGrp = new QGroupBox( tr( "SMESH_BASE_POINT" ), ArgumentsGrp );
- BasePointGrp->setColumnLayout( 0, Qt::Vertical );
- BasePointGrp->layout()->setSpacing( 0 ); BasePointGrp->layout()->setMargin( 0 );
- QGridLayout* BasePointGrpLayout = new QGridLayout( BasePointGrp->layout() );
- BasePointGrpLayout->setAlignment( Qt::AlignTop );
- BasePointGrpLayout->setSpacing( 6 ); BasePointGrpLayout->setMargin( 11 );
-
- SelectBasePointButton = new QToolButton( BasePointGrp );
- SelectBasePointButton->setPixmap( selectImage );
+ AddAngleButton = new QToolButton(AnglesGrp);
+ AddAngleButton->setIcon(addImage);
+
+ RemoveAngleButton = new QToolButton(AnglesGrp);
+ RemoveAngleButton->setIcon(removeImage);
+
+ AngleSpin = new SMESHGUI_SpinBox(AnglesGrp);
- XLab = new QLabel( tr( "SMESH_X" ), BasePointGrp );
- XSpin = new SMESHGUI_SpinBox( BasePointGrp );
- YLab = new QLabel( tr( "SMESH_Y" ), BasePointGrp );
- YSpin = new SMESHGUI_SpinBox( BasePointGrp );
- ZLab = new QLabel( tr( "SMESH_Z" ), BasePointGrp );
- ZSpin = new SMESHGUI_SpinBox( BasePointGrp );
+ LinearAnglesCheck = new QCheckBox(tr("LINEAR_ANGLES"), AnglesGrp);
// layouting
- BasePointGrpLayout->addWidget( SelectBasePointButton, 0, 0 );
- BasePointGrpLayout->addWidget( XLab, 0, 1 );
- BasePointGrpLayout->addWidget( XSpin, 0, 2 );
- BasePointGrpLayout->addWidget( YLab, 0, 3 );
- BasePointGrpLayout->addWidget( YSpin, 0, 4 );
- BasePointGrpLayout->addWidget( ZLab, 0, 5 );
- BasePointGrpLayout->addWidget( ZSpin, 0, 6 );
+ AnglesGrpLayout->addWidget(AnglesList, 0, 0, 4, 1);
+ AnglesGrpLayout->addWidget(AddAngleButton, 0, 1);
+ AnglesGrpLayout->addWidget(RemoveAngleButton, 2, 1);
+ AnglesGrpLayout->addWidget(AngleSpin, 0, 2);
+ AnglesGrpLayout->addWidget(LinearAnglesCheck, 4, 0);
+ AnglesGrpLayout->setRowMinimumHeight(1, 10);
+ AnglesGrpLayout->setRowStretch(3, 10);
+
+ // CheckBox for groups generation
+ MakeGroupsCheck = new QCheckBox(tr("SMESH_MAKE_GROUPS"), GroupArguments);
+ MakeGroupsCheck->setChecked(true);
// layouting
- ArgumentsGrpLayout->addWidget( ElementsLab, 0, 0 );
- ArgumentsGrpLayout->addWidget( SelectElementsButton, 0, 1 );
- ArgumentsGrpLayout->addWidget( ElementsLineEdit, 0, 2 );
- ArgumentsGrpLayout->addMultiCellWidget( MeshCheck, 1, 1, 0, 2 );
- ArgumentsGrpLayout->addMultiCellWidget( PathGrp, 2, 2, 0, 2 );
- ArgumentsGrpLayout->addWidget( AnglesCheck, 3, 0 );
- ArgumentsGrpLayout->addMultiCellWidget( AnglesGrp, 3, 4, 1, 2 );
- ArgumentsGrpLayout->addWidget( BasePointCheck, 5, 0 );
- ArgumentsGrpLayout->addMultiCellWidget( BasePointGrp, 5, 6, 1, 2 );
- ArgumentsGrpLayout->setRowStretch( 4, 10 );
+ GroupArgumentsLayout->addWidget(ElementsLab, 0, 0);
+ GroupArgumentsLayout->addWidget(SelectElementsButton, 0, 1);
+ GroupArgumentsLayout->addWidget(ElementsLineEdit, 0, 2);
+ GroupArgumentsLayout->addWidget(myFilterBtn, 0, 3);
+ GroupArgumentsLayout->addWidget(MeshCheck, 1, 0, 1, 4);
+ GroupArgumentsLayout->addWidget(PathGrp, 2, 0, 1, 4);
+ GroupArgumentsLayout->addWidget(BasePointGrp, 3, 0, 1, 4);
+ GroupArgumentsLayout->addWidget(AnglesGrp, 4, 0, 1, 4);
+ GroupArgumentsLayout->addWidget(MakeGroupsCheck, 5, 0, 1, 4);
/***************************************************************/
// common buttons group box
- ButtonsGrp = new QGroupBox( this );
- ButtonsGrp->setColumnLayout( 0, Qt::Vertical );
- ButtonsGrp->layout()->setSpacing( 0 ); ButtonsGrp->layout()->setMargin( 0 );
- QGridLayout* ButtonsGrpLayout = new QGridLayout( ButtonsGrp->layout() );
- ButtonsGrpLayout->setAlignment( Qt::AlignTop );
- ButtonsGrpLayout->setSpacing( 6 ); ButtonsGrpLayout->setMargin( 11 );
+ GroupButtons = new QGroupBox(this);
+ QHBoxLayout* GroupButtonsLayout = new QHBoxLayout(GroupButtons);
+ GroupButtonsLayout->setSpacing(SPACING); GroupButtonsLayout->setMargin(MARGIN);
- OkButton = new QPushButton( tr( "SMESH_BUT_OK" ), ButtonsGrp );
- OkButton->setAutoDefault( true );
- OkButton->setDefault( true );
+ OkButton = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), GroupButtons);
+ OkButton->setAutoDefault(true);
+ OkButton->setDefault(true);
- ApplyButton = new QPushButton( tr( "SMESH_BUT_APPLY" ), ButtonsGrp );
- ApplyButton->setAutoDefault( true );
+ ApplyButton = new QPushButton(tr("SMESH_BUT_APPLY"), GroupButtons);
+ ApplyButton->setAutoDefault(true);
- CloseButton = new QPushButton( tr( "SMESH_BUT_CLOSE" ), ButtonsGrp );
- CloseButton->setAutoDefault( true );
+ CloseButton = new QPushButton(tr("SMESH_BUT_CLOSE"), GroupButtons);
+ CloseButton->setAutoDefault(true);
+
+ HelpButton = new QPushButton(tr("SMESH_BUT_HELP"), GroupButtons);
+ HelpButton->setAutoDefault(true);
// layouting
- ButtonsGrpLayout->addWidget( OkButton, 0, 0 );
- ButtonsGrpLayout->addWidget( ApplyButton, 0, 1 );
- ButtonsGrpLayout->addWidget( CloseButton, 0, 3 );
- ButtonsGrpLayout->addColSpacing( 2, 10 );
- ButtonsGrpLayout->setColStretch( 2, 10 );
+ GroupButtonsLayout->addWidget(OkButton);
+ GroupButtonsLayout->addSpacing(10);
+ GroupButtonsLayout->addWidget(ApplyButton);
+ GroupButtonsLayout->addSpacing(10);
+ GroupButtonsLayout->addStretch();
+ GroupButtonsLayout->addWidget(CloseButton);
+ GroupButtonsLayout->addWidget(HelpButton);
/***************************************************************/
// layouting
- topLayout->addWidget( ElementsTypeGrp, 0, 0 );
- topLayout->addWidget( ArgumentsGrp, 1, 0 );
- topLayout->addWidget( ButtonsGrp, 2, 0 );
+ topLayout->addWidget(ConstructorsBox);
+ topLayout->addWidget(GroupArguments);
+ topLayout->addWidget(GroupButtons);
/***************************************************************/
// Initialisations
- XSpin->RangeStepAndValidator( -999999.999, +999999.999, 10.0, 3 );
- YSpin->RangeStepAndValidator( -999999.999, +999999.999, 10.0, 3 );
- ZSpin->RangeStepAndValidator( -999999.999, +999999.999, 10.0, 3 );
- AngleSpin->RangeStepAndValidator( -999999.999, +999999.999, 5.0, 3 );
-
- mySelection = Sel;
- mySMESHGUI = SMESHGUI::GetSMESHGUI() ;
- mySMESHGUI->SetActiveDialogBox( this ) ;
-
+ XSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, 3);
+ YSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, 3);
+ ZSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, 3);
+ AngleSpin->RangeStepAndValidator(-180.0, 180.0, 5.0, 3);
+
+ mySelector = (SMESH::GetViewWindow( mySMESHGUI ))->GetSelector();
+
+ mySMESHGUI->SetActiveDialogBox(this);
+
// Costruction of the logical filter for the elements: mesh/sub-mesh/group
- SMESH_ListOfFilter aListOfFilters;
- Handle(SMESH_TypeFilter) aMeshOrSubMeshFilter = new SMESH_TypeFilter( MESHorSUBMESH );
- if ( !aMeshOrSubMeshFilter.IsNull() )
- aListOfFilters.Append( aMeshOrSubMeshFilter );
- Handle(SMESH_TypeFilter) aSmeshGroupFilter = new SMESH_TypeFilter( GROUP );
- if ( !aSmeshGroupFilter.IsNull() )
- aListOfFilters.Append( aSmeshGroupFilter );
-
- myElementsFilter = new SMESH_LogicalFilter( aListOfFilters, SMESH_LogicalFilter::LO_OR );
-
- myPathMeshFilter = new SMESH_TypeFilter( MESH );
-
- Init();
+ SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter (MESHorSUBMESH);
+ SMESH_TypeFilter* aSmeshGroupFilter = new SMESH_TypeFilter (GROUP);
- /***************************************************************/
- // signals-slots connections
- connect( OkButton, SIGNAL( clicked() ), this, SLOT( ClickOnOk() ) );
- connect( CloseButton, SIGNAL( clicked() ), this, SLOT( reject() ) ) ;
- connect( ApplyButton, SIGNAL( clicked() ), this, SLOT( ClickOnApply() ) );
+ QList<SUIT_SelectionFilter*> aListOfFilters;
+ if (aMeshOrSubMeshFilter) aListOfFilters.append(aMeshOrSubMeshFilter);
+ if (aSmeshGroupFilter) aListOfFilters.append(aSmeshGroupFilter);
- connect( AddAngleButton, SIGNAL( clicked() ), this, SLOT( OnAngleAdded() ) );
- connect( RemoveAngleButton, SIGNAL( clicked() ), this, SLOT( OnAngleRemoved() ) );
+ myElementsFilter = new SMESH_LogicalFilter (aListOfFilters, SMESH_LogicalFilter::LO_OR);
+ //myPathMeshFilter = new SMESH_TypeFilter (MESH);
+ myPathMeshFilter = new SMESH_TypeFilter(MESHorSUBMESH);
- connect( ElementsTypeGrp, SIGNAL( clicked( int ) ), SLOT( TypeChanged( int ) ) );
-
- connect( SelectElementsButton, SIGNAL( clicked() ), this, SLOT( SetEditCurrentArgument() ) ) ;
- connect( SelectPathMeshButton, SIGNAL( clicked() ), this, SLOT( SetEditCurrentArgument() ) ) ;
- connect( SelectPathShapeButton, SIGNAL( clicked() ), this, SLOT( SetEditCurrentArgument() ) ) ;
- connect( SelectStartPointButton, SIGNAL( clicked() ), this, SLOT( SetEditCurrentArgument() ) ) ;
- connect( SelectBasePointButton, SIGNAL( clicked() ), this, SLOT( SetEditCurrentArgument() ) ) ;
-
- connect( mySMESHGUI, SIGNAL( SignalDeactivateActiveDialog() ), this, SLOT( DeactivateActiveDialog() ) ) ;
- connect( mySelection, SIGNAL( currentSelectionChanged() ), this, SLOT( SelectionIntoArgument() ) );
- connect( mySMESHGUI, SIGNAL( SignalCloseAllDialogs() ), this, SLOT( reject() ) ) ;
-
- connect( ElementsLineEdit, SIGNAL( textChanged( const QString& ) ),
- SLOT( onTextChange( const QString& ) ) );
- connect( StartPointLineEdit, SIGNAL( textChanged( const QString& ) ),
- SLOT( onTextChange( const QString& ) ) );
-
- connect( MeshCheck, SIGNAL( toggled( bool ) ), SLOT( onSelectMesh() ) );
- connect( AnglesCheck, SIGNAL( toggled( bool ) ), SLOT( onAnglesCheck() ) );
- connect( BasePointCheck, SIGNAL( toggled( bool ) ), SLOT( onBasePointCheck() ) );
-
- AnglesList->installEventFilter( this );
- ElementsLineEdit->installEventFilter( this );
- StartPointLineEdit->installEventFilter( this );
- XSpin->editor()->installEventFilter( this );
- YSpin->editor()->installEventFilter( this );
- ZSpin->editor()->installEventFilter( this );
+ myHelpFileName = "extrusion_along_path_page.html";
+
+ Init();
/***************************************************************/
- // set position and show dialog box
- int x, y ;
- mySMESHGUI->DefineDlgPosition( this, x, y ) ;
- this->move( x, y ) ;
- this->show() ; // displays Dialog
+ // signals-slots connections
+ connect(OkButton, SIGNAL(clicked()), this, SLOT(ClickOnOk()));
+ connect(CloseButton, SIGNAL(clicked()), this, SLOT(reject()));
+ connect(ApplyButton, SIGNAL(clicked()), this, SLOT(ClickOnApply()));
+ connect(HelpButton, SIGNAL(clicked()), this, SLOT(ClickOnHelp()));
+
+ connect(AddAngleButton, SIGNAL(clicked()), this, SLOT(OnAngleAdded()));
+ connect(RemoveAngleButton, SIGNAL(clicked()), this, SLOT(OnAngleRemoved()));
+
+ connect(GroupConstructors, SIGNAL(buttonClicked(int)), SLOT(ConstructorsClicked(int)));
+
+ connect(SelectElementsButton, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
+ connect(SelectPathMeshButton, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
+ connect(SelectStartPointButton, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
+ connect(SelectBasePointButton, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
+
+ connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), this, SLOT(DeactivateActiveDialog()));
+ connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
+ connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), this, SLOT(reject()));
+
+ connect(ElementsLineEdit, SIGNAL(textChanged(const QString&)),
+ SLOT(onTextChange(const QString&)));
+ connect(StartPointLineEdit, SIGNAL(textChanged(const QString&)),
+ SLOT(onTextChange(const QString&)));
+
+ connect(MeshCheck, SIGNAL(toggled(bool)), SLOT(onSelectMesh()));
+
+ AnglesList->installEventFilter(this);
+ ElementsLineEdit->installEventFilter(this);
+ StartPointLineEdit->installEventFilter(this);
+ XSpin->editor()->installEventFilter(this);
+ YSpin->editor()->installEventFilter(this);
+ ZSpin->editor()->installEventFilter(this);
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::~SMESHGUI_ExtrusionAlongPathDlg()
+// function : ~SMESHGUI_ExtrusionAlongPathDlg()
// purpose : destructor
//=================================================================================
SMESHGUI_ExtrusionAlongPathDlg::~SMESHGUI_ExtrusionAlongPathDlg()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::~SMESHGUI_ExtrusionAlongPathDlg");
// no need to delete child widgets, Qt does it all for us
-}
-
-//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::eventFilter
-// purpose : event filter
-//=================================================================================
-bool SMESHGUI_ExtrusionAlongPathDlg::eventFilter( QObject* object, QEvent* event )
-{
- if ( event->type() == QEvent::KeyPress ) {
- QKeyEvent* ke = ( QKeyEvent* )event;
- if ( object == AnglesList ) {
- if ( ke->key() == Key_Delete )
- OnAngleRemoved();
- }
+ if ( myFilterDlg != 0 ) {
+ myFilterDlg->setParent( 0 );
+ delete myFilterDlg;
}
- else if ( event->type() == QEvent::FocusIn ) {
- if ( object == ElementsLineEdit ) {
- if ( myEditCurrentArgument != ElementsLineEdit )
- SetEditCurrentArgument( SelectElementsButton );
- }
- else if ( object == StartPointLineEdit ) {
- if ( myEditCurrentArgument != StartPointLineEdit )
- SetEditCurrentArgument( SelectStartPointButton );
- }
- else if ( object == XSpin->editor() || object == YSpin->editor() || object == ZSpin->editor() ) {
- if ( myEditCurrentArgument != XSpin )
- SetEditCurrentArgument( SelectBasePointButton );
- }
- }
- return QDialog::eventFilter( object, event );
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::Init()
+// function : Init()
// purpose : initialization
//=================================================================================
-void SMESHGUI_ExtrusionAlongPathDlg::Init( bool ResetControls )
+void SMESHGUI_ExtrusionAlongPathDlg::Init (bool ResetControls)
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::Init");
myBusy = false;
myEditCurrentArgument = 0;
-
+
myMesh = SMESH::SMESH_Mesh::_nil();
myIDSource = SMESH::SMESH_IDSource::_nil();
myMeshActor = 0;
- myPathMesh = SMESH::SMESH_Mesh::_nil();
- myPathShape = GEOM::GEOM_Object::_nil();
-
+ myPath = SMESH::SMESH_IDSource::_nil();
+
ElementsLineEdit->clear();
PathMeshLineEdit->clear();
- PathShapeLineEdit->clear();
StartPointLineEdit->clear();
- if( ResetControls ) {
- XSpin->SetValue( 0.0 );
- YSpin->SetValue( 0.0 );
- ZSpin->SetValue( 0.0 );
-
- AngleSpin->SetValue( 45 );
- MeshCheck->setChecked( false );
- TypeChanged( 0 );
+ if (ResetControls) {
+ XSpin->SetValue(0.0);
+ YSpin->SetValue(0.0);
+ ZSpin->SetValue(0.0);
+
+ AngleSpin->SetValue(45);
+ MeshCheck->setChecked(false);
+ ConstructorsClicked(0);
onSelectMesh();
- onAnglesCheck();
- onBasePointCheck();
}
- SetEditCurrentArgument( 0 );
+ SetEditCurrentArgument(0);
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::TypeChanged()
-// purpose : Called when user changes type of elements ( 1d / 2d )
+// function : ConstructorsClicked()
+// purpose : Called when user changes type of elements (1d / 2d)
//=================================================================================
-void SMESHGUI_ExtrusionAlongPathDlg::TypeChanged( int type )
+void SMESHGUI_ExtrusionAlongPathDlg::ConstructorsClicked (int type)
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::TypeChanged");
- if ( myType != type ) {
- disconnect( mySelection, 0, this, 0 );
-
- if ( type == 0 )
- ArgumentsGrp->setTitle( tr( "EXTRUSION_1D" ) );
- else if ( type == 1 )
- ArgumentsGrp->setTitle( tr( "EXTRUSION_2D" ) );
-
- // clear elements ID list
- if ( !MeshCheck->isChecked() ) {
- ElementsLineEdit->clear();
- }
- // set selection mode if necessary
- if( myEditCurrentArgument == ElementsLineEdit ) {
- mySelection->ClearIObjects();
- mySelection->ClearFilters();
- SMESH::SetPickable();
-
- SMESH::SetPointRepresentation( false );
- if ( MeshCheck->isChecked() ) {
- QAD_Application::getDesktop()->SetSelectionMode( ActorSelection );
- mySelection->AddFilter( myElementsFilter );
- }
- else {
- if ( type == 0 )
- QAD_Application::getDesktop()->SetSelectionMode( EdgeSelection, true );
- if ( type == 1 )
- QAD_Application::getDesktop()->SetSelectionMode( FaceSelection, true );
- }
+ if (myType == type) return;
+
+ disconnect(mySelectionMgr, 0, this, 0);
+
+ if (type == 0)
+ GroupArguments->setTitle(tr("EXTRUSION_1D"));
+ else if (type == 1)
+ GroupArguments->setTitle(tr("EXTRUSION_2D"));
+
+ // clear elements ID list
+ if (!MeshCheck->isChecked()) {
+ ElementsLineEdit->clear();
+ }
+ // set selection mode if necessary
+ if (myEditCurrentArgument == ElementsLineEdit) {
+ mySelectionMgr->clearSelected();
+ mySelectionMgr->clearFilters();
+ SMESH::SetPickable();
+
+ SMESH::SetPointRepresentation(false);
+ if (MeshCheck->isChecked()) {
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(ActorSelection);
+ mySelectionMgr->installFilter(myElementsFilter);
+ } else {
+ if (type == 0)
+ {
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(EdgeSelection);
+ }
+ if (type == 1)
+ {
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(FaceSelection);
+ }
}
- connect( mySelection, SIGNAL( currentSelectionChanged() ), this, SLOT( SelectionIntoArgument() ) );
}
- myType = type;
-}
+ connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
+ myType = type;
+}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::ClickOnApply()
+// function : ClickOnApply()
// purpose : Called when user presses <Apply> button
//=================================================================================
bool SMESHGUI_ExtrusionAlongPathDlg::ClickOnApply()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::ClickOnApply");
- if ( mySMESHGUI->ActiveStudyLocked() ) {
+ if (mySMESHGUI->isActiveStudyLocked())
return false;
- }
-
- if( myMesh->_is_nil() || MeshCheck->isChecked() && myIDSource->_is_nil() || !myMeshActor || myPathMesh->_is_nil() || myPathShape->_is_nil() ) {
+
+ //if (myMesh->_is_nil() || MeshCheck->isChecked() && myIDSource->_is_nil() ||
+ // !myMeshActor || myPathMesh->_is_nil() || myPathShape->_is_nil())
+ if ( myMesh->_is_nil() || MeshCheck->isChecked() && myIDSource->_is_nil() ||
+ !myMeshActor || myPath->_is_nil() )
+ return false;
+
+ if (!isValid())
return false;
- }
SMESH::long_array_var anElementsId = new SMESH::long_array;
- if ( MeshCheck->isChecked() ) {
- // If "Select whole mesh, submesh or group" check box is on ->
- // get all elements of the required type from the object selected
-
- // if MESH object is selected
- if ( !CORBA::is_nil( SMESH::SMESH_Mesh::_narrow( myIDSource ) ) ) {
- // get mesh
- SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( myIDSource );
- // get IDs from mesh...
- if ( Elements1dRB->isChecked() )
- // 1d elements
- anElementsId = aMesh->GetElementsByType( SMESH::EDGE );
- else if ( Elements2dRB->isChecked() ) {
- anElementsId = aMesh->GetElementsByType( SMESH::FACE );
- }
- }
- // SUBMESH is selected
- if ( !CORBA::is_nil( SMESH::SMESH_subMesh::_narrow( myIDSource ) ) ) {
- // get submesh
- SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( myIDSource );
- // get IDs from submesh
- if ( Elements1dRB->isChecked() )
- // 1d elements
- anElementsId = aSubMesh->GetElementsByType( SMESH::EDGE );
- else if ( Elements2dRB->isChecked() )
- // 2d elements
- anElementsId = aSubMesh->GetElementsByType( SMESH::FACE );
- }
- // GROUP is selected
- if ( !CORBA::is_nil( SMESH::SMESH_GroupBase::_narrow( myIDSource ) ) ) {
- // get smesh group
- SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( myIDSource );
- // get IDs from group
- // 1d elements or 2d elements
- if ( Elements1dRB->isChecked() && aGroup->GetType() == SMESH::EDGE ||
- Elements2dRB->isChecked() && aGroup->GetType() == SMESH::FACE )
- anElementsId = aGroup->GetListOfID();
- }
- }
- else {
+ if (!MeshCheck->isChecked()) {
// If "Select whole mesh, submesh or group" check box is off ->
// use only elements of given type selected by user
SMDS_Mesh* aMesh = myMeshActor->GetObject()->GetMesh();
- if ( aMesh ) {
- QStringList aListElementsId = QStringList::split( " ", ElementsLineEdit->text(), false );
+ if (aMesh) {
+ QStringList aListElementsId = ElementsLineEdit->text().split(" ", QString::SkipEmptyParts);
anElementsId = new SMESH::long_array;
- anElementsId->length( aListElementsId.count() );
+ anElementsId->length(aListElementsId.count());
bool bOk;
int j = 0;
- for ( int i = 0; i < aListElementsId.count(); i++ ) {
- long ind = aListElementsId[ i ].toLong( &bOk );
- if ( bOk ) {
- const SMDS_MeshElement* e = aMesh->FindElement( ind );
- if ( e ) {
- bool typeMatch = Elements1dRB->isChecked() && e->GetType() == SMDSAbs_Edge ||
- Elements2dRB->isChecked() && e->GetType() == SMDSAbs_Face;
- if ( typeMatch )
- anElementsId[ j++ ] = ind;
- }
- }
+ for (int i = 0; i < aListElementsId.count(); i++) {
+ long ind = aListElementsId[ i ].toLong(&bOk);
+ if (bOk) {
+ const SMDS_MeshElement* e = aMesh->FindElement(ind);
+ if (e) {
+ bool typeMatch = Elements1dRB->isChecked() && e->GetType() == SMDSAbs_Edge ||
+ Elements2dRB->isChecked() && e->GetType() == SMDSAbs_Face;
+ if (typeMatch)
+ anElementsId[ j++ ] = ind;
+ }
+ }
}
- anElementsId->length( j );
+ anElementsId->length(j);
+ }
+
+ if (anElementsId->length() <= 0) {
+ return false;
}
- }
-
- if ( anElementsId->length() <= 0 ) {
- return false;
}
- if ( StartPointLineEdit->text().stripWhiteSpace().isEmpty() ) {
+ if (StartPointLineEdit->text().trimmed().isEmpty()) {
return false;
}
-
+
bool bOk;
- long aNodeStart = StartPointLineEdit->text().toLong( &bOk );
- if ( !bOk ) {
+ long aNodeStart = StartPointLineEdit->text().toLong(&bOk);
+ if (!bOk) {
return false;
}
-
+
+ QStringList aParameters;
+
// get angles
SMESH::double_array_var anAngles = new SMESH::double_array;
- if ( AnglesCheck->isChecked() ) {
- anAngles->length( AnglesList->count() );
+ if (AnglesGrp->isChecked()) {
+ anAngles->length(myAnglesList.count());
int j = 0;
- bool bOk;
- for ( int i = 0; i < AnglesList->count(); i++ ) {
- double angle = AnglesList->text( i ).toDouble( &bOk );
- if ( bOk )
- anAngles[ j++ ] = angle*PI/180;
+ for (int i = 0; i < myAnglesList.count(); i++) {
+ double angle = myAnglesList[i];
+ anAngles[ j++ ] = angle*PI/180;
+ aParameters << AnglesList->item(i)->text();
}
- anAngles->length( j );
+ anAngles->length(j);
}
// get base point
SMESH::PointStruct aBasePoint;
- if ( BasePointCheck->isChecked() ) {
+ if (BasePointGrp->isChecked()) {
aBasePoint.x = XSpin->GetValue();
aBasePoint.y = YSpin->GetValue();
aBasePoint.z = ZSpin->GetValue();
}
-
+
+ aParameters << XSpin->text();
+ aParameters << YSpin->text();
+ aParameters << ZSpin->text();
+
try {
- QAD_WaitCursor wc;
+ SUIT_OverrideCursor wc;
SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
- SMESH::SMESH_MeshEditor::Extrusion_Error retVal =
- aMeshEditor->ExtrusionAlongPath( anElementsId.inout(), myPathMesh, myPathShape, aNodeStart,
- AnglesCheck->isChecked(), anAngles.inout(),
- BasePointCheck->isChecked(), aBasePoint );
+ //if ( LinearAnglesCheck->isChecked() ) {
+ // anAngles = aMeshEditor->LinearAnglesVariation( myPathMesh, myPathShape, anAngles );
+ //}
+
+ SMESH::SMESH_MeshEditor::Extrusion_Error retVal;
+ /*
+ if ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() ) {
+ if( MeshCheck->isChecked() ) {
+ if( GetConstructorId() == 0 )
+ SMESH::ListOfGroups_var groups =
+ aMeshEditor->ExtrusionAlongPathObject1DMakeGroups(myIDSource, myPathMesh,
+ myPathShape, aNodeStart,
+ AnglesGrp->isChecked(), anAngles,
+ BasePointGrp->isChecked(), aBasePoint, retVal);
+ else
+ SMESH::ListOfGroups_var groups =
+ aMeshEditor->ExtrusionAlongPathObject2DMakeGroups(myIDSource, myPathMesh,
+ myPathShape, aNodeStart,
+ AnglesGrp->isChecked(), anAngles,
+ BasePointGrp->isChecked(), aBasePoint, retVal);
+ }
+ else
+ SMESH::ListOfGroups_var groups =
+ aMeshEditor->ExtrusionAlongPathMakeGroups(anElementsId, myPathMesh,
+ myPathShape, aNodeStart,
+ AnglesGrp->isChecked(), anAngles,
+ BasePointGrp->isChecked(), aBasePoint, retVal);
+ }
+ else {
+ if( MeshCheck->isChecked() ) {
+ if( GetConstructorId() == 0 )
+ retVal = aMeshEditor->ExtrusionAlongPathObject1D(myIDSource, myPathMesh,
+ myPathShape, aNodeStart,
+ AnglesGrp->isChecked(), anAngles,
+ BasePointGrp->isChecked(), aBasePoint);
+ else
+ retVal = aMeshEditor->ExtrusionAlongPathObject2D(myIDSource, myPathMesh,
+ myPathShape, aNodeStart,
+ AnglesGrp->isChecked(), anAngles,
+ BasePointGrp->isChecked(), aBasePoint);
+ }
+ else
+ retVal = aMeshEditor->ExtrusionAlongPath(anElementsId, myPathMesh,
+ myPathShape, aNodeStart,
+ AnglesGrp->isChecked(), anAngles,
+ BasePointGrp->isChecked(), aBasePoint);
+ }
+ */
+
+ bool NeedGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() );
+ SMESH::ElementType ElemType = SMESH::FACE;
+ if( GetConstructorId() == 0 )
+ ElemType = SMESH::EDGE;
+ if( !MeshCheck->isChecked() ) {
+ SMESH::ListOfGroups_var groups =
+ aMeshEditor->ExtrusionAlongPathX(anElementsId, myPath, aNodeStart, AnglesGrp->isChecked(),
+ anAngles, LinearAnglesCheck->isChecked(),
+ BasePointGrp->isChecked(), aBasePoint,
+ NeedGroups, ElemType, retVal);
+ }
+ else {
+ SMESH::ListOfGroups_var groups =
+ aMeshEditor->ExtrusionAlongPathObjX(myIDSource, myPath, aNodeStart, AnglesGrp->isChecked(),
+ anAngles, LinearAnglesCheck->isChecked(),
+ BasePointGrp->isChecked(), aBasePoint,
+ NeedGroups, ElemType, retVal);
+ }
+
- wc.stop();
- switch ( retVal ) {
+ if( retVal == SMESH::SMESH_MeshEditor::EXTR_OK )
+ myMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
+
+ //wc.stop();
+ wc.suspend();
+ switch (retVal) {
case SMESH::SMESH_MeshEditor::EXTR_NO_ELEMENTS:
- QAD_MessageBox::warn1( QAD_Application::getDesktop(),
- tr( "SMESH_ERROR" ),
- tr( "NO_ELEMENTS_SELECTED" ),
- tr( "SMESH_BUT_OK" ) );
+ SUIT_MessageBox::warning(this,
+ tr("SMESH_ERROR"),
+ tr("NO_ELEMENTS_SELECTED"));
return false; break;
case SMESH::SMESH_MeshEditor::EXTR_PATH_NOT_EDGE:
- QAD_MessageBox::warn1( QAD_Application::getDesktop(),
- tr( "SMESH_ERROR" ),
- tr( "SELECTED_PATH_IS_NOT_EDGE" ),
- tr( "SMESH_BUT_OK" ) );
+ SUIT_MessageBox::warning(this,
+ tr("SMESH_ERROR"),
+ tr("SELECTED_PATH_IS_NOT_EDGE"));
return false; break;
case SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE:
- QAD_MessageBox::warn1( QAD_Application::getDesktop(),
- tr( "SMESH_ERROR" ),
- tr( "BAD_SHAPE_TYPE" ),
- tr( "SMESH_BUT_OK" ) );
+ SUIT_MessageBox::warning(this,
+ tr("SMESH_ERROR"),
+ tr("BAD_SHAPE_TYPE"));
return false; break;
case SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE:
- QAD_MessageBox::warn1( QAD_Application::getDesktop(),
- tr( "SMESH_ERROR" ),
- tr( "EXTR_BAD_STARTING_NODE" ),
- tr( "SMESH_BUT_OK" ) );
+ SUIT_MessageBox::warning(this,
+ tr("SMESH_ERROR"),
+ tr("EXTR_BAD_STARTING_NODE"));
return false; break;
case SMESH::SMESH_MeshEditor::EXTR_BAD_ANGLES_NUMBER:
- QAD_MessageBox::warn1( QAD_Application::getDesktop(),
- tr( "SMESH_ERROR" ),
- tr( "WRONG_ANGLES_NUMBER" ),
- tr( "SMESH_BUT_OK" ) );
+ SUIT_MessageBox::warning(this,
+ tr("SMESH_ERROR"),
+ tr("WRONG_ANGLES_NUMBER"));
return false; break;
case SMESH::SMESH_MeshEditor::EXTR_CANT_GET_TANGENT:
- QAD_MessageBox::warn1( QAD_Application::getDesktop(),
- tr( "SMESH_ERROR" ),
- tr( "CANT_GET_TANGENT" ),
- tr( "SMESH_BUT_OK" ) );
+ SUIT_MessageBox::warning(this,
+ tr("SMESH_ERROR"),
+ tr("CANT_GET_TANGENT"));
return false; break;
case SMESH::SMESH_MeshEditor::EXTR_OK:
break;
}
- }
- catch( ... ) {
+ } catch (...) {
return false;
}
-
- mySelection->ClearIObjects();
- SMESH::UpdateView();
- Init( false );
- TypeChanged( GetConstructorId() );
+
+ //mySelectionMgr->clearSelected();
+ SMESH::Update( myMeshActor->getIO(), myMeshActor->GetVisibility() );
+ if ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() )
+ mySMESHGUI->updateObjBrowser(true); // new groups may appear
+ //SMESH::UpdateView();
+ Init(false);
+ ConstructorsClicked(GetConstructorId());
return true;
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::ClickOnOk()
+// function : ClickOnOk()
// purpose : Called when user presses <OK> button
//=================================================================================
void SMESHGUI_ExtrusionAlongPathDlg::ClickOnOk()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::ClickOnOk");
- if ( !ClickOnApply() )
- return;
- reject();
+ if (ClickOnApply())
+ reject();
+}
+
+//=================================================================================
+// function : ClickOnHelp()
+// purpose :
+//=================================================================================
+void SMESHGUI_ExtrusionAlongPathDlg::ClickOnHelp()
+{
+ LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
+ if (app)
+ app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName);
+ else {
+ QString platform;
+#ifdef WIN32
+ platform = "winapplication";
+#else
+ platform = "application";
+#endif
+ SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
+ tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
+ arg(app->resourceMgr()->stringValue("ExternalBrowser",
+ platform)).
+ arg(myHelpFileName));
+ }
+}
+
+//=================================================================================
+// function : reject()
+// purpose : Called when dialog box is closed
+//=================================================================================
+void SMESHGUI_ExtrusionAlongPathDlg::reject()
+{
+ disconnect(mySelectionMgr, 0, this, 0);
+ mySelectionMgr->clearFilters();
+ //mySelectionMgr->clearSelected();
+ if (SMESH::GetCurrentVtkView()) {
+ SMESH::RemoveFilters(); // PAL6938 -- clean all mesh entity filters
+ SMESH::SetPointRepresentation(false);
+ SMESH::SetPickable();
+ }
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(ActorSelection);
+ mySMESHGUI->ResetState();
+ QDialog::reject();
}
//=======================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::onTextChange
-// purpose :
+// function : onTextChange()
+// purpose :
//=======================================================================
-
-void SMESHGUI_ExtrusionAlongPathDlg::onTextChange(const QString& theNewText)
+void SMESHGUI_ExtrusionAlongPathDlg::onTextChange (const QString& theNewText)
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::onTextChange");
QLineEdit* send = (QLineEdit*)sender();
- if ( send != StartPointLineEdit && send != ElementsLineEdit )
- send = ElementsLineEdit;
// return if busy
- if ( myBusy )
- return;
+ if (myBusy) return;
// set busy flag
- SetBusy sb( this );
-
- if ( send == ElementsLineEdit && myEditCurrentArgument == ElementsLineEdit ) {
+ SetBusy sb (this);
+
+ if (send != StartPointLineEdit && send != ElementsLineEdit)
+ send = ElementsLineEdit;
+
+ if (send == ElementsLineEdit && myEditCurrentArgument == ElementsLineEdit) {
// hilight entered elements
SMDS_Mesh* aMesh = 0;
- if ( myMeshActor )
+ if (myMeshActor)
aMesh = myMeshActor->GetObject()->GetMesh();
- if ( aMesh ) {
- mySelection->ClearIObjects();
- mySelection->AddIObject( myMeshActor->getIO() );
-
- QStringList aListId = QStringList::split( " ", theNewText, false );
+
+ if (aMesh) {
+ //mySelectionMgr->clearSelected();
+ //mySelectionMgr->AddIObject(myMeshActor->getIO());
+ SALOME_ListIO aList;
+ aList.Append(myMeshActor->getIO());
+ mySelectionMgr->setSelectedObjects(aList, false);
+
+ QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
bool bOk;
- for ( int i = 0; i < aListId.count(); i++ ) {
- long ind = aListId[ i ].toLong( &bOk );
- if ( bOk ) {
- const SMDS_MeshElement* e = aMesh->FindElement( ind );
- if ( e ) {
- // check also type of element
- bool typeMatch = Elements1dRB->isChecked() && e->GetType() == SMDSAbs_Edge ||
- Elements2dRB->isChecked() && e->GetType() == SMDSAbs_Face;
- if ( typeMatch ) {
- if ( !mySelection->IsIndexSelected( myMeshActor->getIO(), e->GetID() ) )
- mySelection->AddOrRemoveIndex( myMeshActor->getIO(), e->GetID(), true );
- }
- }
- }
+ const Handle(SALOME_InteractiveObject)& anIO = myMeshActor->getIO();
+ TColStd_MapOfInteger newIndices;
+ for (int i = 0; i < aListId.count(); i++) {
+ long ind = aListId[ i ].toLong(&bOk);
+ if (bOk) {
+ const SMDS_MeshElement* e = aMesh->FindElement(ind);
+ if (e) {
+ // check also type of element
+ bool typeMatch = Elements1dRB->isChecked() && e->GetType() == SMDSAbs_Edge ||
+ Elements2dRB->isChecked() && e->GetType() == SMDSAbs_Face;
+ if (typeMatch)
+ newIndices.Add(e->GetID());
+ }
+ }
}
+ mySelector->AddOrRemoveIndex(anIO, newIndices, false);
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->highlight( anIO, true, true );
}
}
- else if ( send == StartPointLineEdit && myEditCurrentArgument == StartPointLineEdit ) {
- if ( !myPathMesh->_is_nil() ) {
- SMESH_Actor* aPathActor = SMESH::FindActorByObject( myPathMesh );
+ else if (send == StartPointLineEdit &&
+ myEditCurrentArgument == StartPointLineEdit) {
+ if (!myPath->_is_nil()) {
+ SMESH_Actor* aPathActor = SMESH::FindActorByObject(myPath);
SMDS_Mesh* aMesh = 0;
- if ( aPathActor )
- aMesh = aPathActor->GetObject()->GetMesh();
- if ( aMesh ) {
- mySelection->ClearIObjects();
- mySelection->AddIObject( aPathActor->getIO() );
-
- bool bOk;
- long ind = theNewText.toLong( &bOk );
- if ( bOk ) {
- const SMDS_MeshNode* n = aMesh->FindNode( ind );
- if ( n ) {
- if ( !mySelection->IsIndexSelected( aPathActor->getIO(), n->GetID() ) ) {
- mySelection->AddOrRemoveIndex( aPathActor->getIO(), n->GetID(), true );
- }
- }
- }
+ if (aPathActor)
+ aMesh = aPathActor->GetObject()->GetMesh();
+ if (aMesh) {
+ //mySelectionMgr->clearSelected();
+ //mySelectionMgr->AddIObject(aPathActor->getIO());
+ SALOME_ListIO aList;
+ aList.Append(aPathActor->getIO());
+ mySelectionMgr->setSelectedObjects(aList, false);
+
+ bool bOk;
+ long ind = theNewText.toLong(&bOk);
+ if (bOk) {
+ const SMDS_MeshNode* n = aMesh->FindNode(ind);
+ if (n) {
+ //if (!mySelectionMgr->IsIndexSelected(aPathActor->getIO(), n->GetID())) {
+ TColStd_MapOfInteger newIndices;
+ newIndices.Add(n->GetID());
+ mySelector->AddOrRemoveIndex( aPathActor->getIO(), newIndices, false );
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->highlight( aPathActor->getIO(), true, true );
+ }
+ }
}
}
}
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::SelectionIntoArgument()
+// function : SelectionIntoArgument()
// purpose : Called when selection as changed or other case
//=================================================================================
void SMESHGUI_ExtrusionAlongPathDlg::SelectionIntoArgument()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::SelectionIntoArgument");
- // return if busy
- if ( myBusy )
- return;
-
+ if (myBusy) return;
+
// return if dialog box is inactive
- if ( !ButtonsGrp->isEnabled() )
+ if (!GroupButtons->isEnabled())
return;
// selected objects count
- int nbSel = mySelection->IObjectCount();
+ const SALOME_ListIO& aList = mySelector->StoredIObjects();
+ int nbSel = aList.Extent();
+ if (nbSel != 1)
+ return;
// set busy flag
- SetBusy sb( this );
+ SetBusy sb (this);
- if ( myEditCurrentArgument == ElementsLineEdit ) {
+ if (myEditCurrentArgument == ElementsLineEdit) {
// we are now selecting mesh elements (or whole mesh/submesh/group)
// reset
ElementsLineEdit->clear();
myMesh = SMESH::SMESH_Mesh::_nil();
myIDSource = SMESH::SMESH_IDSource::_nil();
myMeshActor = 0;
-
- // only one object is acceptable
- if( nbSel != 1 )
- return;
// try to get mesh from selection
- Handle( SALOME_InteractiveObject ) IO = mySelection->firstIObject();
- myMesh = SMESH::GetMeshByIO( IO );
- if( myMesh->_is_nil() )
+ Handle(SALOME_InteractiveObject) IO = aList.First();
+ myMesh = SMESH::GetMeshByIO(IO);
+ if (myMesh->_is_nil())
return;
+
+ // MakeGroups is available if there are groups
+ if ( myMesh->NbGroups() == 0 ) {
+ MakeGroupsCheck->setChecked(false);
+ MakeGroupsCheck->setEnabled(false);
+ } else {
+ MakeGroupsCheck->setEnabled(true);
+ }
// find actor
- myMeshActor = SMESH::FindActorByObject( myMesh );
- if ( !myMeshActor )
+ myMeshActor = SMESH::FindActorByObject(myMesh);
+ if (!myMeshActor)
return;
- if ( MeshCheck->isChecked() ) {
+ if (MeshCheck->isChecked()) {
// If "Select whole mesh, submesh or group" check box is on ->
// get ID source and put it's name to the edit box
QString aString;
- SMESH::GetNameOfSelectedIObjects( mySelection, aString );
+ SMESH::GetNameOfSelectedIObjects(mySelectionMgr, aString);
- myIDSource = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
- ElementsLineEdit->setText( aString );
- }
- else {
+ myIDSource = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(IO);
+ ElementsLineEdit->setText(aString);
+ } else {
// If "Select whole mesh, submesh or group" check box is off ->
// try to get selected elements IDs
QString aString;
- int aNbUnits = SMESH::GetNameOfSelectedElements( mySelection, aString );
- ElementsLineEdit->setText( aString );
+ //int aNbUnits = SMESH::GetNameOfSelectedElements(mySelectionMgr, aString);
+ SMESH::GetNameOfSelectedElements(mySelector, IO, aString);
+ ElementsLineEdit->setText(aString);
}
}
- else if ( myEditCurrentArgument == PathMeshLineEdit ) {
+ else if (myEditCurrentArgument == PathMeshLineEdit) {
// we are now selecting path mesh
// reset
PathMeshLineEdit->clear();
- myPathMesh = SMESH::SMESH_Mesh::_nil();
- PathShapeLineEdit->clear();
- myPathShape = GEOM::GEOM_Object::_nil();
+ myPath = SMESH::SMESH_IDSource::_nil();
StartPointLineEdit->clear();
-
- // only one object is acceptable
- if( nbSel != 1 )
- return;
-
+
// try to get mesh from selection
- Handle( SALOME_InteractiveObject ) IO = mySelection->firstIObject();
- myPathMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>( IO );
- if( myPathMesh->_is_nil() )
- return;
-
- QString aString;
- SMESH::GetNameOfSelectedIObjects( mySelection, aString );
- PathMeshLineEdit->setText( aString );
- }
- else if ( myEditCurrentArgument == PathShapeLineEdit ) {
- // we are now selecting path mesh
- // reset
- PathShapeLineEdit->clear();
- myPathShape = GEOM::GEOM_Object::_nil();
- StartPointLineEdit->clear();
-
- // return if path mesh is not yet selected
- if ( myPathMesh->_is_nil() )
- return;
-
- // only one object is acceptable
- if( nbSel != 1 )
+ Handle(SALOME_InteractiveObject) IO = aList.First();
+ myPath = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(IO);
+ if( myPath->_is_nil() )
return;
-
- // try to get shape from selection
- Handle( SALOME_InteractiveObject ) IO = mySelection->firstIObject();
- myPathShape = SMESH::IObjectToInterface<GEOM::GEOM_Object>( IO );
- if ( myPathShape->_is_nil() )
- return;
-
+
QString aString;
- SMESH::GetNameOfSelectedIObjects( mySelection, aString );
- PathShapeLineEdit->setText( aString );
+ SMESH::GetNameOfSelectedIObjects(mySelectionMgr, aString);
+ PathMeshLineEdit->setText(aString);
}
- else if ( myEditCurrentArgument == StartPointLineEdit ) {
+ else if (myEditCurrentArgument == StartPointLineEdit) {
// we are now selecting start point of path
// reset
StartPointLineEdit->clear();
// return if path mesh or path shape is not yet selected
- if ( myPathMesh->_is_nil() || myPathShape->_is_nil() )
- return;
-
- // only one object is acceptable
- if( nbSel != 1 )
+ if( myPath->_is_nil() )
return;
// try to get shape from selection
- Handle( SALOME_InteractiveObject ) IO = mySelection->firstIObject();
+ Handle(SALOME_InteractiveObject) IO = aList.First();
+
+ SMESH_Actor* aPathActor = SMESH::FindActorByObject(myPath);
+ if ( !aPathActor )
+ return;
QString aString;
- int aNbUnits = SMESH::GetNameOfSelectedElements( mySelection, aString );
- if ( aNbUnits == 1 )
- StartPointLineEdit->setText( aString.stripWhiteSpace() );
- }
- else if ( myEditCurrentArgument == XSpin ) {
+ int aNbUnits = SMESH::GetNameOfSelectedElements(mySelector, aPathActor->getIO(), aString);
+ if (aNbUnits == 1)
+ StartPointLineEdit->setText(aString.trimmed());
+
+ } else if (myEditCurrentArgument == XSpin) {
// we are now selecting base point
// reset is not performed here!
// return if is not enabled
- if ( !BasePointGrp->isEnabled() )
+ if (!BasePointGrp->isChecked())
return;
- // only one object is acceptable
- if( nbSel != 1 )
- return;
-
// try to get shape from selection
- Handle( SALOME_InteractiveObject ) IO = mySelection->firstIObject();
-
+ Handle(SALOME_InteractiveObject) IO = aList.First();
+
// check if geom vertex is selected
- GEOM::GEOM_Object_var aGeomObj = SMESH::IObjectToInterface<GEOM::GEOM_Object>( IO );
+ GEOM::GEOM_Object_var aGeomObj = SMESH::IObjectToInterface<GEOM::GEOM_Object>(IO);
TopoDS_Vertex aVertex;
- if( !aGeomObj->_is_nil() ) {
- if( aGeomObj->IsShape() && GEOMBase::GetShape( aGeomObj, aVertex ) && !aVertex.IsNull() ) {
- gp_Pnt aPnt = BRep_Tool::Pnt( aVertex );
- XSpin->SetValue( aPnt.X() );
- YSpin->SetValue( aPnt.Y() );
- ZSpin->SetValue( aPnt.Z() );
+ if (!aGeomObj->_is_nil()) {
+ if (aGeomObj->IsShape() && GEOMBase::GetShape(aGeomObj, aVertex) && !aVertex.IsNull()) {
+ gp_Pnt aPnt = BRep_Tool::Pnt(aVertex);
+ XSpin->SetValue(aPnt.X());
+ YSpin->SetValue(aPnt.Y());
+ ZSpin->SetValue(aPnt.Z());
}
return;
}
// check if smesh node is selected
- SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( IO );
- if( aMesh->_is_nil() )
+ SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(IO);
+ if (aMesh->_is_nil())
return;
QString aString;
- int aNbUnits = SMESH::GetNameOfSelectedNodes( mySelection, aString );
+ int aNbUnits = SMESH::GetNameOfSelectedNodes(mySelector, myMeshActor->getIO(), aString);
// return if more than one node is selected
- if( aNbUnits != 1 )
+ if (aNbUnits != 1)
return;
-
- SMESH_Actor* aMeshActor = SMESH::FindActorByObject( aMesh );
- if ( !aMeshActor )
+
+ SMESH_Actor* aMeshActor = SMESH::FindActorByObject(aMesh);
+ if (!aMeshActor)
return;
SMDS_Mesh* mesh = aMeshActor->GetObject()->GetMesh();
if (!mesh)
return;
- const SMDS_MeshNode* n = mesh->FindNode( aString.toLong() );
- if ( !n )
+ const SMDS_MeshNode* n = mesh->FindNode(aString.toLong());
+ if (!n)
return;
- XSpin->SetValue( n->X() );
- YSpin->SetValue( n->Y() );
- ZSpin->SetValue( n->Z() );
+ XSpin->SetValue(n->X());
+ YSpin->SetValue(n->Y());
+ ZSpin->SetValue(n->Z());
}
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument()
+// function : SetEditCurrentArgument()
// purpose :
//=================================================================================
void SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument");
QToolButton* send = (QToolButton*)sender();
- if ( send != SelectElementsButton &&
- send != SelectPathMeshButton &&
- send != SelectPathShapeButton &&
- send != SelectStartPointButton &&
- send != SelectBasePointButton )
+ if (send != SelectElementsButton &&
+ send != SelectPathMeshButton &&
+ send != SelectStartPointButton &&
+ send != SelectBasePointButton)
return;
- SetEditCurrentArgument( send );
+ SetEditCurrentArgument(send);
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument()
+// function : SetEditCurrentArgument()
// purpose :
//=================================================================================
-void SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument( QToolButton* button )
+void SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument (QToolButton* button)
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument(button)");
- disconnect( mySelection, 0, this, 0 );
- mySelection->ClearIObjects();
- mySelection->ClearFilters();
+ disconnect(mySelectionMgr, 0, this, 0);
+ mySelectionMgr->clearSelected();
+ mySelectionMgr->clearFilters();
SMESH::SetPickable();
-
- if( button == SelectElementsButton ) {
+
+ if (button == SelectElementsButton) {
myEditCurrentArgument = ElementsLineEdit;
- SMESH::SetPointRepresentation( false );
- if ( MeshCheck->isChecked() ) {
- QAD_Application::getDesktop()->SetSelectionMode( ActorSelection );
- mySelection->AddFilter( myElementsFilter );
- }
- else {
- if ( Elements1dRB->isChecked() )
- QAD_Application::getDesktop()->SetSelectionMode( EdgeSelection, true );
- else if ( Elements2dRB->isChecked() )
- QAD_Application::getDesktop()->SetSelectionMode( FaceSelection, true );
+ SMESH::SetPointRepresentation(false);
+ if (MeshCheck->isChecked()) {
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(ActorSelection);
+ mySelectionMgr->installFilter(myElementsFilter);
+ } else {
+ if (Elements1dRB->isChecked())
+ {
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(EdgeSelection);
+ }
+ else if (Elements2dRB->isChecked())
+ {
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(FaceSelection);
+ }
}
- }
- else if ( button == SelectPathMeshButton ) {
+ } else if (button == SelectPathMeshButton) {
myEditCurrentArgument = PathMeshLineEdit;
- SMESH::SetPointRepresentation( false );
- QAD_Application::getDesktop()->SetSelectionMode( ActorSelection );
- mySelection->AddFilter( myPathMeshFilter );
- }
- else if ( button == SelectPathShapeButton ) {
- myEditCurrentArgument = PathShapeLineEdit;
- SMESH::SetPointRepresentation( false );
- QAD_Application::getDesktop()->SetSelectionMode( ActorSelection );
-
- if ( !myPathMesh->_is_nil() ) {
- GEOM::GEOM_Object_var aMainShape = myPathMesh->GetShapeToMesh();
- SMESH_Actor* aPathActor = SMESH::FindActorByObject( myPathMesh );
-
- if ( !aMainShape->_is_nil() && aPathActor )
- mySelection->AddFilter( new SMESH_NumberFilter( "GEOM", TopAbs_SHAPE, -1, TopAbs_EDGE, aMainShape ) );
- //SMESH::SetPickable( aPathActor );
- }
+ SMESH::SetPointRepresentation(false);
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(ActorSelection);
+ mySelectionMgr->installFilter(myPathMeshFilter);
}
- else if ( button == SelectStartPointButton ) {
+ else if (button == SelectStartPointButton) {
myEditCurrentArgument = StartPointLineEdit;
- if ( !myPathMesh->_is_nil() ) {
- SMESH_Actor* aPathActor = SMESH::FindActorByObject( myPathMesh );
- if ( aPathActor ) {
- SMESH::SetPointRepresentation( true );
- QAD_Application::getDesktop()->SetSelectionMode( NodeSelection, true );
- SMESH::SetPickable( aPathActor );
+ //if (!myPathMesh->_is_nil()) {
+ if (!myPath->_is_nil()) {
+ SMESH_Actor* aPathActor = SMESH::FindActorByObject(myPath);
+ if (aPathActor) {
+ SMESH::SetPointRepresentation(true);
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(NodeSelection);
+ SMESH::SetPickable(aPathActor);
}
}
}
- else if ( button == SelectBasePointButton ) {
+ else if (button == SelectBasePointButton) {
myEditCurrentArgument = XSpin;
- SMESH::SetPointRepresentation( true );
- QAD_Application::getDesktop()->SetSelectionMode( NodeSelection, true );
-
- SMESH_ListOfFilter aListOfFilters;
- Handle(SMESH_TypeFilter) aMeshOrSubMeshFilter = new SMESH_TypeFilter( MESHorSUBMESH );
- if ( !aMeshOrSubMeshFilter.IsNull() )
- aListOfFilters.Append( aMeshOrSubMeshFilter );
- Handle(SMESH_TypeFilter) aSmeshGroupFilter = new SMESH_TypeFilter( GROUP );
- if ( !aSmeshGroupFilter.IsNull() )
- aListOfFilters.Append( aSmeshGroupFilter );
- //Handle(GEOM_ShapeTypeFilter) aVertexFilter = new GEOM_ShapeTypeFilter( TopAbs_VERTEX );
- Handle(SMESH_NumberFilter) aVertexFilter = new SMESH_NumberFilter( "GEOM", TopAbs_SHAPE, -1, TopAbs_VERTEX, GEOM::GEOM_Object::_nil() );
- if ( !aVertexFilter.IsNull() )
- aListOfFilters.Append( aVertexFilter );
-
- mySelection->AddFilter( new SMESH_LogicalFilter( aListOfFilters, SMESH_LogicalFilter::LO_OR ) );
+ SMESH::SetPointRepresentation(true);
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode(NodeSelection);
+
+ SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter(MESHorSUBMESH);
+ SMESH_TypeFilter* aSmeshGroupFilter = new SMESH_TypeFilter(GROUP);
+ SMESH_NumberFilter* aVertexFilter = new SMESH_NumberFilter ("GEOM", TopAbs_SHAPE,
+ -1, TopAbs_VERTEX);
+ QList<SUIT_SelectionFilter*> aListOfFilters;
+ if (aMeshOrSubMeshFilter) aListOfFilters.append(aMeshOrSubMeshFilter);
+ if (aSmeshGroupFilter) aListOfFilters.append(aSmeshGroupFilter);
+ if (aVertexFilter) aListOfFilters.append(aVertexFilter);
+
+ mySelectionMgr->installFilter(new SMESH_LogicalFilter
+ (aListOfFilters, SMESH_LogicalFilter::LO_OR));
}
- if ( myEditCurrentArgument && !myEditCurrentArgument->hasFocus() )
+ if (myEditCurrentArgument && !myEditCurrentArgument->hasFocus())
myEditCurrentArgument->setFocus();
- connect( mySelection, SIGNAL( currentSelectionChanged() ), this, SLOT( SelectionIntoArgument() ) );
+ connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
SelectionIntoArgument();
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::DeactivateActiveDialog()
+// function : DeactivateActiveDialog()
// purpose : Deactivates this dialog
//=================================================================================
void SMESHGUI_ExtrusionAlongPathDlg::DeactivateActiveDialog()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::DeactivateActiveDialog");
- if ( ElementsTypeGrp->isEnabled() ) {
- ElementsTypeGrp->setEnabled( false );
- ArgumentsGrp->setEnabled( false );
- ButtonsGrp->setEnabled( false );
- mySMESHGUI->ResetState();
- mySMESHGUI->SetActiveDialogBox( 0 );
+ if (ConstructorsBox->isEnabled()) {
+ ConstructorsBox->setEnabled(false);
+ GroupArguments->setEnabled(false);
+ GroupButtons->setEnabled(false);
+ mySMESHGUI->ResetState();
+ mySMESHGUI->SetActiveDialogBox(0);
}
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::ActivateThisDialog()
+// function : ActivateThisDialog()
// purpose : Activates this dialog
//=================================================================================
void SMESHGUI_ExtrusionAlongPathDlg::ActivateThisDialog()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::ActivateThisDialog");
// Emit a signal to deactivate the active dialog
- mySMESHGUI->EmitSignalDeactivateDialog();
- ElementsTypeGrp->setEnabled( true );
- ArgumentsGrp->setEnabled( true );
- ButtonsGrp->setEnabled( true );
-
- mySMESHGUI->SetActiveDialogBox( this );
+ mySMESHGUI->EmitSignalDeactivateDialog();
+ ConstructorsBox->setEnabled(true);
+ GroupArguments->setEnabled(true);
+ GroupButtons->setEnabled(true);
- TypeChanged( GetConstructorId() );
+ mySMESHGUI->SetActiveDialogBox(this);
+
+ ConstructorsClicked(GetConstructorId());
SelectionIntoArgument();
}
//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::enterEvent()
+// function : enterEvent()
// purpose : Mouse enter event
//=================================================================================
-void SMESHGUI_ExtrusionAlongPathDlg::enterEvent(QEvent* e)
+void SMESHGUI_ExtrusionAlongPathDlg::enterEvent (QEvent*)
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::enterEvent");
- if ( ElementsTypeGrp->isEnabled() )
- return;
- ActivateThisDialog();
-}
-
-//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::reject()
-// purpose : Called when dialog box is closed
-//=================================================================================
-void SMESHGUI_ExtrusionAlongPathDlg::reject()
-{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::reject");
- disconnect( mySelection, 0, this, 0 );
- mySelection->ClearFilters();
- mySelection->ClearIObjects();
- SMESH::SetPickable();
- SMESH::SetPointRepresentation( false );
- QAD_Application::getDesktop()->SetSelectionMode( ActorSelection );
- mySMESHGUI->ResetState() ;
- QDialog::reject();
-}
-
-//=================================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::GetConstructorId()
-// purpose :
-//=================================================================================
-int SMESHGUI_ExtrusionAlongPathDlg::GetConstructorId()
-{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::GetConstructorId");
- if ( ElementsTypeGrp != NULL && ElementsTypeGrp->selected() != NULL )
- return ElementsTypeGrp->id( ElementsTypeGrp->selected() );
- return -1;
+ if (!ConstructorsBox->isEnabled())
+ ActivateThisDialog();
}
//=======================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::onSelectMesh
+// function : onSelectMesh()
// purpose :
//=======================================================================
void SMESHGUI_ExtrusionAlongPathDlg::onSelectMesh()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::onSelectMesh");
bool toSelectMesh = MeshCheck->isChecked();
-
- ElementsLineEdit->setReadOnly( toSelectMesh );
- ElementsLab->setText( toSelectMesh ? tr( "SMESH_NAME" ) : tr( "SMESH_ID_ELEMENTS" ) );
+
+ ElementsLineEdit->setReadOnly(toSelectMesh);
+ ElementsLineEdit->setValidator(toSelectMesh ? 0 : myIdValidator);
+ ElementsLab->setText(toSelectMesh ? tr("SMESH_NAME") : tr("SMESH_ID_ELEMENTS"));
ElementsLineEdit->clear();
-
- SetEditCurrentArgument( SelectElementsButton );
-}
+ myFilterBtn->setEnabled(!toSelectMesh);
-//=======================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::onAnglesCheck
-// purpose : called when "Use Angles" check box is switched
-//=======================================================================
-void SMESHGUI_ExtrusionAlongPathDlg::onAnglesCheck()
-{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::onAnglesCheck");
- AnglesGrp->setEnabled( AnglesCheck->isChecked() );
+ SetEditCurrentArgument(SelectElementsButton);
}
-//=======================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::onBasePointCheck
-// purpose : called when "Use Base Point" check box is switched
-//=======================================================================
-void SMESHGUI_ExtrusionAlongPathDlg::onBasePointCheck()
+//=================================================================================
+// function : GetConstructorId()
+// purpose :
+//=================================================================================
+int SMESHGUI_ExtrusionAlongPathDlg::GetConstructorId()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::onBasePointCheck");
- BasePointGrp->setEnabled( BasePointCheck->isChecked() );
+ return GroupConstructors->checkedId();
}
//=======================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::OnAngleAdded
+// function : OnAngleAdded()
// purpose : Called when user adds angle to the list
//=======================================================================
void SMESHGUI_ExtrusionAlongPathDlg::OnAngleAdded()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::OnAngleAdded");
- AnglesList->insertItem( QString::number( AngleSpin->GetValue() ) );
+ QString msg;
+ if( !AngleSpin->isValid( msg, true ) ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ return;
+ }
+ AnglesList->addItem(AngleSpin->text());
+ myAnglesList.append(AngleSpin->GetValue());
+
+ updateLinearAngles();
}
//=======================================================================
-// function : SMESHGUI_ExtrusionAlongPathDlg::OnAngleRemoved
+// function : OnAngleRemoved()
// purpose : Called when user removes angle(s) from the list
//=======================================================================
void SMESHGUI_ExtrusionAlongPathDlg::OnAngleRemoved()
{
- MESSAGE("SMESHGUI_ExtrusionAlongPathDlg::OnAngleRemoved");
- QList<QListBoxItem> aList;
- aList.setAutoDelete( false );
- for ( int i = 0; i < AnglesList->count(); i++ )
- if ( AnglesList->isSelected( i ) )
- aList.append( AnglesList->item( i ) );
-
- for ( int i = 0; i < aList.count(); i++ )
- delete aList.at( i );
+ QList<QListWidgetItem*> aList = AnglesList->selectedItems();
+ QListWidgetItem* anItem;
+ foreach(anItem, aList) {
+ myAnglesList.removeAt(AnglesList->row(anItem));
+ delete anItem;
+ }
+
+ updateLinearAngles();
+}
+
+//=================================================================================
+// function : eventFilter()
+// purpose : event filter ???
+//=================================================================================
+bool SMESHGUI_ExtrusionAlongPathDlg::eventFilter (QObject* object, QEvent* event)
+{
+ if (event->type() == QEvent::KeyPress) {
+ QKeyEvent* ke = (QKeyEvent*)event;
+ if (object == AnglesList) {
+ if (ke->key() == Qt::Key_Delete)
+ OnAngleRemoved();
+ }
+ }
+ else if (event->type() == QEvent::FocusIn) {
+ if (object == ElementsLineEdit) {
+ if (myEditCurrentArgument != ElementsLineEdit)
+ SetEditCurrentArgument(SelectElementsButton);
+ }
+ else if (object == StartPointLineEdit) {
+ if (myEditCurrentArgument != StartPointLineEdit)
+ SetEditCurrentArgument(SelectStartPointButton);
+ }
+ else if (object == XSpin->editor() || object == YSpin->editor() || object == ZSpin->editor()) {
+ if (myEditCurrentArgument != XSpin)
+ SetEditCurrentArgument(SelectBasePointButton);
+ }
+ }
+ return QDialog::eventFilter(object, event);
+}
+
+//=================================================================================
+// function : keyPressEvent()
+// purpose :
+//=================================================================================
+void SMESHGUI_ExtrusionAlongPathDlg::keyPressEvent( QKeyEvent* e )
+{
+ QDialog::keyPressEvent( e );
+ if ( e->isAccepted() )
+ return;
+
+ if ( e->key() == Qt::Key_F1 ) {
+ e->accept();
+ ClickOnHelp();
+ }
+}
+
+//=================================================================================
+// function : setFilters()
+// purpose : SLOT. Called when "Filter" button pressed.
+//=================================================================================
+void SMESHGUI_ExtrusionAlongPathDlg::setFilters()
+{
+ if(myMesh->_is_nil()) {
+ SUIT_MessageBox::critical(this,
+ tr("SMESH_ERROR"),
+ tr("NO_MESH_SELECTED"));
+ return;
+ }
+ if ( !myFilterDlg )
+ {
+ QList<int> types;
+ types.append( SMESH::EDGE );
+ types.append( SMESH::FACE );
+ myFilterDlg = new SMESHGUI_FilterDlg( mySMESHGUI, types );
+ }
+ myFilterDlg->Init( Elements1dRB->isChecked() ? SMESH::EDGE : SMESH::FACE );
+
+ myFilterDlg->SetSelection();
+ myFilterDlg->SetMesh( myMesh );
+ myFilterDlg->SetSourceWg( ElementsLineEdit );
+
+ myFilterDlg->show();
+}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool SMESHGUI_ExtrusionAlongPathDlg::isValid()
+{
+ QString msg;
+ bool ok = true;
+ ok = XSpin->isValid( msg, true ) && ok;
+ ok = YSpin->isValid( msg, true ) && ok;
+ ok = ZSpin->isValid( msg, true ) && ok;
+
+ if( !ok ) {
+ QString str( tr( "SMESH_INCORRECT_INPUT" ) );
+ if ( !msg.isEmpty() )
+ str += "\n" + msg;
+ SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
+ return false;
+ }
+ return true;
}
+//=================================================================================
+// function : updateLinearAngles
+// purpose :
+//=================================================================================
+void SMESHGUI_ExtrusionAlongPathDlg::updateLinearAngles()
+{
+ bool enableLinear = true;
+ for( int row = 0, nbRows = AnglesList->count(); row < nbRows; row++ ) {
+ if( QListWidgetItem* anItem = AnglesList->item( row ) ) {
+ enableLinear = false;
+ anItem->text().toDouble(&enableLinear);
+ if( !enableLinear )
+ break;
+ }
+ }
+ if( !enableLinear )
+ LinearAnglesCheck->setChecked( false );
+ LinearAnglesCheck->setEnabled( enableLinear );
+}
