src/SMESHGUI/SMESHGUI_ExtrusionAlongPathDlg.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   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, or (at your option) any later version.
  10 //
  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.
  15 //
  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
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 // SMESH SMESHGUI : GUI for SMESH component
  24 // File   : SMESHGUI_ExtrusionAlongPathDlg.cxx
  25 // Author : Vadim SANDLER, Open CASCADE S.A.S.
  26 // SMESH includes
  27
  28 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
  29
  30 #include "SMESHGUI.h"
  31 #include "SMESHGUI_Utils.h"
  32 #include "SMESHGUI_VTKUtils.h"
  33 #include "SMESHGUI_MeshUtils.h"
  34 #include "SMESHGUI_SpinBox.h"
  35 #include "SMESHGUI_IdValidator.h"
  36 #include "SMESHGUI_FilterDlg.h"
  37 #include "SMESHGUI_MeshEditPreview.h"
  38
  39 #include <SMESH_Actor.h>
  40 #include <SMESH_TypeFilter.hxx>
  41 #include <SMESH_NumberFilter.hxx>
  42 #include <SMESH_LogicalFilter.hxx>
  43
  44 #include <SMDS_Mesh.hxx>
  45
  46 // SALOME GEOM includes
  47 #include <GEOMBase.h>
  48
  49 // SALOME GUI includes
  50 #include <SUIT_ResourceMgr.h>
  51 #include <SUIT_OverrideCursor.h>
  52 #include <SUIT_Desktop.h>
  53 #include <SUIT_MessageBox.h>
  54 #include <SUIT_Session.h>
  55
  56 #include <LightApp_Application.h>
  57 #include <LightApp_SelectionMgr.h>
  58
  59 #include <SVTK_ViewWindow.h>
  60
  61 // OCCT includes
  62 #include <BRep_Tool.hxx>
  63 #include <TopoDS_Vertex.hxx>
  64 #include <gp_Pnt.hxx>
  65 #include <TColStd_MapOfInteger.hxx>
  66
  67 // Qt includes
  68 #include <QButtonGroup>
  69 #include <QGroupBox>
  70 #include <QLabel>
  71 #include <QLineEdit>
  72 #include <QPushButton>
  73 #include <QToolButton>
  74 #include <QRadioButton>
  75 #include <QCheckBox>
  76 #include <QListWidget>
  77 #include <QVBoxLayout>
  78 #include <QHBoxLayout>
  79 #include <QGridLayout>
  80 #include <QKeyEvent>
  81
  82 // IDL includes
  83 #include <SALOMEconfig.h>
  84 #include CORBA_SERVER_HEADER(SMESH_Group)
  85 #include CORBA_SERVER_HEADER(SMESH_MeshEditor)
  86
  87 #define SPACING 6
  88 #define MARGIN  11
  89
  90 class SMESHGUI_ExtrusionAlongPathDlg::SetBusy
  91 {
  92 public:
  93   SetBusy( SMESHGUI_ExtrusionAlongPathDlg* _dlg )
  94   {
  95     myDlg = _dlg;
  96     myDlg->myBusy = true;
  97   }
  98
  99   ~SetBusy()
 100   {
 101     myDlg->myBusy = false;
 102   }
 103
 104 private:
 105   SMESHGUI_ExtrusionAlongPathDlg* myDlg;
 106 };
 107
 108 //=================================================================================
 109 // function : SMESHGUI_ExtrusionAlongPathDlg()
 110 // purpose  : constructor
 111 //=================================================================================
 112 SMESHGUI_ExtrusionAlongPathDlg::SMESHGUI_ExtrusionAlongPathDlg( SMESHGUI* theModule )
 113   : SMESHGUI_PreviewDlg( theModule ),
 114     mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ),
 115     myFilterDlg( 0 )
 116 {
 117   SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( mySMESHGUI );
 118   QPixmap edgeImage   ( mgr->loadPixmap("SMESH", tr("ICON_DLG_EDGE")));
 119   QPixmap faceImage   ( mgr->loadPixmap("SMESH", tr("ICON_DLG_TRIANGLE")));
 120   QPixmap selectImage ( mgr->loadPixmap("SMESH", tr("ICON_SELECT")));
 121   QPixmap addImage    ( mgr->loadPixmap("SMESH", tr("ICON_APPEND")));
 122   QPixmap removeImage ( mgr->loadPixmap("SMESH", tr("ICON_REMOVE")));
 123
 124   myType = -1;
 125
 126   setModal( false );
 127   setAttribute( Qt::WA_DeleteOnClose, true );
 128   setWindowTitle(tr("EXTRUSION_ALONG_PATH"));
 129   setSizeGripEnabled(true);
 130
 131   QVBoxLayout* topLayout = new QVBoxLayout(this);
 132   topLayout->setSpacing(SPACING);
 133   topLayout->setMargin(MARGIN);
 134
 135   /***************************************************************/
 136   // Elements type group box (1d / 2d elements)
 137   ConstructorsBox = new QGroupBox(tr("SMESH_EXTRUSION"), this);
 138   GroupConstructors = new QButtonGroup(this);
 139   QHBoxLayout* ConstructorsBoxLayout = new QHBoxLayout(ConstructorsBox);
 140   ConstructorsBoxLayout->setSpacing(SPACING); ConstructorsBoxLayout->setMargin(MARGIN);
 141
 142   Elements1dRB = new QRadioButton(ConstructorsBox);
 143   Elements1dRB->setIcon(edgeImage);
 144   Elements2dRB = new QRadioButton(ConstructorsBox);
 145   Elements2dRB->setIcon(faceImage);
 146   Elements1dRB->setChecked(true);
 147
 148   // layouting
 149   ConstructorsBoxLayout->addWidget(Elements1dRB);
 150   ConstructorsBoxLayout->addWidget(Elements2dRB);
 151   GroupConstructors->addButton(Elements1dRB,  0);
 152   GroupConstructors->addButton(Elements2dRB, 1);
 153
 154   /***************************************************************/
 155   // Arguments group box
 156   GroupArguments = new QGroupBox(tr("EXTRUSION_1D"), this);
 157   QGridLayout* GroupArgumentsLayout = new QGridLayout(GroupArguments);
 158   GroupArgumentsLayout->setSpacing(SPACING); GroupArgumentsLayout->setMargin(MARGIN);
 159
 160   myIdValidator = new SMESHGUI_IdValidator(this);
 161
 162   // Controls for elements selection
 163   ElementsLab = new QLabel(tr("SMESH_ID_ELEMENTS"), GroupArguments);
 164
 165   SelectElementsButton = new QToolButton(GroupArguments);
 166   SelectElementsButton->setIcon(selectImage);
 167
 168   ElementsLineEdit = new QLineEdit(GroupArguments);
 169   ElementsLineEdit->setValidator(myIdValidator);
 170   ElementsLineEdit->setMaxLength(-1);
 171   myFilterBtn = new QPushButton( tr( "SMESH_BUT_FILTER" ), GroupArguments );
 172   connect(myFilterBtn,   SIGNAL(clicked()), this, SLOT(setFilters()));
 173
 174   // Controls for the whole mesh selection
 175   MeshCheck = new QCheckBox(tr("SMESH_SELECT_WHOLE_MESH"), GroupArguments);
 176
 177   // Controls for path selection
 178   PathGrp = new QGroupBox(tr("SMESH_PATH"), GroupArguments);
 179   QGridLayout* PathGrpLayout = new QGridLayout(PathGrp);
 180   PathGrpLayout->setSpacing(SPACING); PathGrpLayout->setMargin(MARGIN);
 181
 182   // Controls for path mesh selection
 183   QLabel* PathMeshLab = new QLabel(tr("SMESH_PATH_MESH"), PathGrp);
 184
 185   SelectPathMeshButton = new QToolButton(PathGrp);
 186   SelectPathMeshButton->setIcon(selectImage);
 187
 188   PathMeshLineEdit = new QLineEdit(PathGrp);
 189   PathMeshLineEdit->setReadOnly(true);
 190
 191   // Controls for path starting point selection
 192   QLabel* StartPointLab = new QLabel(tr("SMESH_PATH_START"), PathGrp);
 193
 194   SelectStartPointButton = new QToolButton(PathGrp);
 195   SelectStartPointButton->setIcon(selectImage);
 196
 197   StartPointLineEdit = new QLineEdit(PathGrp);
 198   StartPointLineEdit->setValidator(new QIntValidator(this));
 199
 200   // layouting
 201   PathGrpLayout->addWidget(PathMeshLab,            0, 0);
 202   PathGrpLayout->addWidget(SelectPathMeshButton,   0, 1);
 203   PathGrpLayout->addWidget(PathMeshLineEdit,       0, 2);
 204   PathGrpLayout->addWidget(StartPointLab,          1, 0);
 205   PathGrpLayout->addWidget(SelectStartPointButton, 1, 1);
 206   PathGrpLayout->addWidget(StartPointLineEdit,     1, 2);
 207
 208   BasePointGrp = new QGroupBox(tr("SMESH_BASE_POINT"), GroupArguments);
 209   BasePointGrp->setCheckable(true);
 210   BasePointGrp->setChecked(false);
 211   QHBoxLayout* BasePointGrpLayout = new QHBoxLayout(BasePointGrp);
 212   BasePointGrpLayout->setSpacing(SPACING); BasePointGrpLayout->setMargin(MARGIN);
 213
 214   SelectBasePointButton = new QToolButton(BasePointGrp);
 215   SelectBasePointButton->setIcon(selectImage);
 216
 217   QLabel* XLab  = new QLabel(tr("SMESH_X"), BasePointGrp);
 218   XSpin = new SMESHGUI_SpinBox(BasePointGrp);
 219   QLabel* YLab  = new QLabel(tr("SMESH_Y"), BasePointGrp);
 220   YSpin = new SMESHGUI_SpinBox(BasePointGrp);
 221   QLabel* ZLab  = new QLabel(tr("SMESH_Z"), BasePointGrp);
 222   ZSpin = new SMESHGUI_SpinBox(BasePointGrp);
 223
 224   // layouting
 225   BasePointGrpLayout->addWidget(SelectBasePointButton);
 226   BasePointGrpLayout->addWidget(XLab);
 227   BasePointGrpLayout->addWidget(XSpin);
 228   BasePointGrpLayout->addWidget(YLab);
 229   BasePointGrpLayout->addWidget(YSpin);
 230   BasePointGrpLayout->addWidget(ZLab);
 231   BasePointGrpLayout->addWidget(ZSpin);
 232
 233   AnglesGrp = new QGroupBox(tr("SMESH_ANGLES"), GroupArguments);
 234   AnglesGrp->setCheckable(true);
 235   AnglesGrp->setChecked(false);
 236   QGridLayout* AnglesGrpLayout = new QGridLayout(AnglesGrp);
 237   AnglesGrpLayout->setSpacing(SPACING); AnglesGrpLayout->setMargin(MARGIN);
 238
 239   AnglesList = new QListWidget(AnglesGrp);
 240   AnglesList->setSelectionMode(QListWidget::ExtendedSelection);
 241
 242   AddAngleButton = new QToolButton(AnglesGrp);
 243   AddAngleButton->setIcon(addImage);
 244
 245   RemoveAngleButton = new QToolButton(AnglesGrp);
 246   RemoveAngleButton->setIcon(removeImage);
 247
 248   AngleSpin = new SMESHGUI_SpinBox(AnglesGrp);
 249
 250   LinearAnglesCheck = new QCheckBox(tr("LINEAR_ANGLES"), AnglesGrp);
 251
 252   // layouting
 253   AnglesGrpLayout->addWidget(AnglesList,        0, 0, 4, 1);
 254   AnglesGrpLayout->addWidget(AddAngleButton,    0, 1);
 255   AnglesGrpLayout->addWidget(RemoveAngleButton, 2, 1);
 256   AnglesGrpLayout->addWidget(AngleSpin,         0, 2);
 257   AnglesGrpLayout->addWidget(LinearAnglesCheck, 4, 0);
 258   AnglesGrpLayout->setRowMinimumHeight(1, 10);
 259   AnglesGrpLayout->setRowStretch(3, 10);
 260
 261   // CheckBox for groups generation
 262   MakeGroupsCheck = new QCheckBox(tr("SMESH_MAKE_GROUPS"), GroupArguments);
 263   MakeGroupsCheck->setChecked(true);
 264
 265   //Preview check box
 266   myPreviewCheckBox = new QCheckBox(tr("PREVIEW"), GroupArguments);
 267
 268   // layouting
 269   GroupArgumentsLayout->addWidget(ElementsLab,          0, 0);
 270   GroupArgumentsLayout->addWidget(SelectElementsButton, 0, 1);
 271   GroupArgumentsLayout->addWidget(ElementsLineEdit,     0, 2);
 272   GroupArgumentsLayout->addWidget(myFilterBtn,          0, 3);
 273   GroupArgumentsLayout->addWidget(MeshCheck,            1, 0, 1, 4);
 274   GroupArgumentsLayout->addWidget(PathGrp,              2, 0, 1, 4);
 275   GroupArgumentsLayout->addWidget(BasePointGrp,         3, 0, 1, 4);
 276   GroupArgumentsLayout->addWidget(AnglesGrp,            4, 0, 1, 4);
 277   GroupArgumentsLayout->addWidget(myPreviewCheckBox,    5, 0, 1, 4);
 278   GroupArgumentsLayout->addWidget(MakeGroupsCheck,      6, 0, 1, 4);
 279
 280   /***************************************************************/
 281   // common buttons group box
 282   GroupButtons = new QGroupBox(this);
 283   QHBoxLayout* GroupButtonsLayout = new QHBoxLayout(GroupButtons);
 284   GroupButtonsLayout->setSpacing(SPACING); GroupButtonsLayout->setMargin(MARGIN);
 285
 286   OkButton = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), GroupButtons);
 287   OkButton->setAutoDefault(true);
 288   OkButton->setDefault(true);
 289
 290   ApplyButton = new QPushButton(tr("SMESH_BUT_APPLY"), GroupButtons);
 291   ApplyButton->setAutoDefault(true);
 292
 293   CloseButton = new QPushButton(tr("SMESH_BUT_CLOSE"), GroupButtons);
 294   CloseButton->setAutoDefault(true);
 295
 296   HelpButton = new QPushButton(tr("SMESH_BUT_HELP"), GroupButtons);
 297   HelpButton->setAutoDefault(true);
 298
 299   // layouting
 300   GroupButtonsLayout->addWidget(OkButton);
 301   GroupButtonsLayout->addSpacing(10);
 302   GroupButtonsLayout->addWidget(ApplyButton);
 303   GroupButtonsLayout->addSpacing(10);
 304   GroupButtonsLayout->addStretch();
 305   GroupButtonsLayout->addWidget(CloseButton);
 306   GroupButtonsLayout->addWidget(HelpButton);
 307
 308   /***************************************************************/
 309   // layouting
 310   topLayout->addWidget(ConstructorsBox);
 311   topLayout->addWidget(GroupArguments);
 312   topLayout->addWidget(GroupButtons);
 313
 314   /***************************************************************/
 315   // Initialisations
 316   XSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
 317   YSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
 318   ZSpin->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
 319   AngleSpin->RangeStepAndValidator(-180.0, 180.0, 5.0, "angle_precision");
 320
 321   mySelector = (SMESH::GetViewWindow( mySMESHGUI ))->GetSelector();
 322
 323   mySMESHGUI->SetActiveDialogBox(this);
 324
 325   // Costruction of the logical filter for the elements: mesh/sub-mesh/group
 326   SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter (SMESH::MESHorSUBMESH);
 327   SMESH_TypeFilter* aSmeshGroupFilter    = new SMESH_TypeFilter (SMESH::GROUP);
 328
 329   QList<SUIT_SelectionFilter*> aListOfFilters;
 330   if (aMeshOrSubMeshFilter) aListOfFilters.append(aMeshOrSubMeshFilter);
 331   if (aSmeshGroupFilter)    aListOfFilters.append(aSmeshGroupFilter);
 332
 333   myElementsFilter = new SMESH_LogicalFilter (aListOfFilters, SMESH_LogicalFilter::LO_OR);
 334   //myPathMeshFilter = new SMESH_TypeFilter (SMESH::MESH);
 335   myPathMeshFilter = new SMESH_TypeFilter(SMESH::MESHorSUBMESH);
 336
 337   myHelpFileName = "extrusion_along_path_page.html";
 338
 339   Init();
 340
 341   /***************************************************************/
 342   // signals-slots connections
 343   connect(OkButton,     SIGNAL(clicked()), this, SLOT(ClickOnOk()));
 344   connect(CloseButton,  SIGNAL(clicked()), this, SLOT(reject()));
 345   connect(ApplyButton,  SIGNAL(clicked()), this, SLOT(ClickOnApply()));
 346   connect(HelpButton,   SIGNAL(clicked()), this, SLOT(ClickOnHelp()));
 347
 348   connect(AddAngleButton,    SIGNAL(clicked()), this, SLOT(OnAngleAdded()));
 349   connect(RemoveAngleButton, SIGNAL(clicked()), this, SLOT(OnAngleRemoved()));
 350
 351   connect(GroupConstructors, SIGNAL(buttonClicked(int)), SLOT(ConstructorsClicked(int)));
 352
 353   connect(SelectElementsButton,   SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
 354   connect(SelectPathMeshButton,   SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
 355   connect(SelectStartPointButton, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
 356   connect(SelectBasePointButton,  SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
 357   connect(BasePointGrp,       SIGNAL(toggled(bool)), this, SLOT(SetEditCurrentArgument()));
 358
 359   connect(mySMESHGUI,  SIGNAL(SignalDeactivateActiveDialog()), this, SLOT(DeactivateActiveDialog()));
 360   connect(mySelectionMgr, SIGNAL(currentSelectionChanged()),      this, SLOT(SelectionIntoArgument()));
 361   connect(mySMESHGUI,  SIGNAL(SignalCloseAllDialogs()),        this, SLOT(reject()));
 362
 363   connect(ElementsLineEdit, SIGNAL(textChanged(const QString&)),
 364           SLOT(onTextChange(const QString&)));
 365   connect(StartPointLineEdit, SIGNAL(textChanged(const QString&)),
 366           SLOT(onTextChange(const QString&)));
 367
 368   connect(MeshCheck,      SIGNAL(toggled(bool)), SLOT(onSelectMesh()));
 369
 370   connect(XSpin,  SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
 371   connect(YSpin,  SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
 372   connect(ZSpin,  SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
 373   connect(AddAngleButton,  SIGNAL(clicked()), this, SLOT(toDisplaySimulation()));
 374   connect(RemoveAngleButton, SIGNAL(clicked()), this, SLOT(toDisplaySimulation()));
 375   connect(LinearAnglesCheck, SIGNAL(toggled(bool)), SLOT(onSelectMesh()));
 376
 377
 378   //To Connect preview check box
 379   connectPreviewControl();
 380
 381   AnglesList->installEventFilter(this);
 382   ElementsLineEdit->installEventFilter(this);
 383   StartPointLineEdit->installEventFilter(this);
 384   XSpin->editor()->installEventFilter(this);
 385   YSpin->editor()->installEventFilter(this);
 386   ZSpin->editor()->installEventFilter(this);
 387 }
 388
 389 //=================================================================================
 390 // function : ~SMESHGUI_ExtrusionAlongPathDlg()
 391 // purpose  : destructor
 392 //=================================================================================
 393 SMESHGUI_ExtrusionAlongPathDlg::~SMESHGUI_ExtrusionAlongPathDlg()
 394 {
 395   // no need to delete child widgets, Qt does it all for us
 396   if ( myFilterDlg != 0 ) {
 397     myFilterDlg->setParent( 0 );
 398     delete myFilterDlg;
 399   }
 400 }
 401
 402 //=================================================================================
 403 // function : Init()
 404 // purpose  : initialization
 405 //=================================================================================
 406 void SMESHGUI_ExtrusionAlongPathDlg::Init (bool ResetControls)
 407 {
 408   myBusy = false;
 409   myEditCurrentArgument = 0;
 410
 411   myMesh      = SMESH::SMESH_Mesh::_nil();
 412   myIDSource  = SMESH::SMESH_IDSource::_nil();
 413   myMeshActor = 0;
 414   myPath  = SMESH::SMESH_IDSource::_nil();
 415
 416   ElementsLineEdit->clear();
 417   PathMeshLineEdit->clear();
 418   StartPointLineEdit->clear();
 419
 420   if (ResetControls) {
 421     XSpin->SetValue(0.0);
 422     YSpin->SetValue(0.0);
 423     ZSpin->SetValue(0.0);
 424
 425     AngleSpin->SetValue(45);
 426     MeshCheck->setChecked(false);
 427     ConstructorsClicked(0);
 428     onSelectMesh();
 429     myPreviewCheckBox->setChecked(false);
 430     onDisplaySimulation(false);
 431   }
 432   SetEditCurrentArgument(0);
 433 }
 434
 435 //=================================================================================
 436 // function : ConstructorsClicked()
 437 // purpose  : Called when user changes type of elements (1d / 2d)
 438 //=================================================================================
 439 void SMESHGUI_ExtrusionAlongPathDlg::ConstructorsClicked (int type)
 440 {
 441   if (myType == type) return;
 442
 443   disconnect(mySelectionMgr, 0, this, 0);
 444
 445   hidePreview();
 446
 447   if (type == 0)
 448     GroupArguments->setTitle(tr("EXTRUSION_1D"));
 449   else if (type == 1)
 450     GroupArguments->setTitle(tr("EXTRUSION_2D"));
 451
 452   // clear elements ID list
 453   if (!MeshCheck->isChecked()) {
 454     ElementsLineEdit->clear();
 455   }
 456   // set selection mode if necessary
 457   if (myEditCurrentArgument == ElementsLineEdit) {
 458     mySelectionMgr->clearSelected();
 459     mySelectionMgr->clearFilters();
 460     SMESH::SetPickable();
 461
 462     SMESH::SetPointRepresentation(false);
 463     if (MeshCheck->isChecked()) {
 464       if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 465         aViewWindow->SetSelectionMode(ActorSelection);
 466       mySelectionMgr->installFilter(myElementsFilter);
 467     } else {
 468       if (type == 0)
 469         {
 470           if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 471             aViewWindow->SetSelectionMode(EdgeSelection);
 472         }
 473       if (type == 1)
 474         {
 475           if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 476             aViewWindow->SetSelectionMode(FaceSelection);
 477         }
 478     }
 479   }
 480   connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
 481
 482   myType = type;
 483 }
 484
 485 //=================================================================================
 486 // function : ClickOnApply()
 487 // purpose  : Called when user presses <Apply> button
 488 //=================================================================================
 489 bool SMESHGUI_ExtrusionAlongPathDlg::ClickOnApply()
 490 {
 491   if (mySMESHGUI->isActiveStudyLocked())
 492     return false;
 493
 494   //if (myMesh->_is_nil() || MeshCheck->isChecked() && myIDSource->_is_nil() ||
 495   //    !myMeshActor || myPathMesh->_is_nil() || myPathShape->_is_nil())
 496   if ( myMesh->_is_nil() || (MeshCheck->isChecked() && myIDSource->_is_nil()) ||
 497        /*!myMeshActor ||*/ myPath->_is_nil() )
 498     return false;
 499
 500   if (!isValid())
 501     return false;
 502
 503   SMESH::long_array_var anElementsId = getSelectedElements();
 504
 505   if (StartPointLineEdit->text().trimmed().isEmpty()) {
 506     return false;
 507   }
 508
 509   bool bOk;
 510   long aNodeStart = StartPointLineEdit->text().toLong(&bOk);
 511   if (!bOk) {
 512     return false;
 513   }
 514
 515   QStringList aParameters;
 516
 517   //get angles
 518   SMESH::double_array_var anAngles = getAngles();
 519
 520   for (int i = 0; i < myAnglesList.count(); i++)
 521     aParameters << AnglesList->item(i)->text();
 522
 523
 524   // get base point
 525   SMESH::PointStruct aBasePoint;
 526   if (BasePointGrp->isChecked()) {
 527     aBasePoint.x = XSpin->GetValue();
 528     aBasePoint.y = YSpin->GetValue();
 529     aBasePoint.z = ZSpin->GetValue();
 530   }
 531
 532   aParameters << XSpin->text();
 533   aParameters << YSpin->text();
 534   aParameters << ZSpin->text();
 535
 536   try {
 537     SUIT_OverrideCursor wc;
 538
 539     SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
 540     SMESH::SMESH_MeshEditor::Extrusion_Error retVal;
 541
 542     myMesh->SetParameters( aParameters.join(":").toLatin1().constData() );
 543
 544     bool NeedGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() );
 545     SMESH::ElementType ElemType = SMESH::FACE;
 546     if( GetConstructorId() == 0 )
 547       ElemType = SMESH::EDGE;
 548     if( !MeshCheck->isChecked() ) {
 549       SMESH::ListOfGroups_var groups =
 550         aMeshEditor->ExtrusionAlongPathX(anElementsId, myPath, aNodeStart, AnglesGrp->isChecked(),
 551                                          anAngles, LinearAnglesCheck->isChecked(),
 552                                          BasePointGrp->isChecked(), aBasePoint,
 553                                          NeedGroups, ElemType, retVal);
 554     }
 555     else {
 556       SMESH::ListOfGroups_var groups =
 557         aMeshEditor->ExtrusionAlongPathObjX(myIDSource, myPath, aNodeStart, AnglesGrp->isChecked(),
 558                                           anAngles, LinearAnglesCheck->isChecked(),
 559                                           BasePointGrp->isChecked(), aBasePoint,
 560                                           NeedGroups, ElemType, retVal);
 561     }
 562
 563
 564     wc.suspend();
 565     switch (retVal) {
 566     case SMESH::SMESH_MeshEditor::EXTR_NO_ELEMENTS:
 567       SUIT_MessageBox::warning(this,
 568                                tr("SMESH_ERROR"),
 569                                tr("NO_ELEMENTS_SELECTED"));
 570       return false; break;
 571     case SMESH::SMESH_MeshEditor::EXTR_PATH_NOT_EDGE:
 572       SUIT_MessageBox::warning(this,
 573                                tr("SMESH_ERROR"),
 574                                tr("SELECTED_PATH_IS_NOT_EDGE"));
 575       return false; break;
 576     case SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE:
 577       SUIT_MessageBox::warning(this,
 578                                tr("SMESH_ERROR"),
 579                                tr("BAD_SHAPE_TYPE"));
 580       return false; break;
 581     case SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE:
 582       SUIT_MessageBox::warning(this,
 583                                tr("SMESH_ERROR"),
 584                                tr("EXTR_BAD_STARTING_NODE"));
 585       return false; break;
 586     case SMESH::SMESH_MeshEditor::EXTR_BAD_ANGLES_NUMBER:
 587       SUIT_MessageBox::warning(this,
 588                                tr("SMESH_ERROR"),
 589                                tr("WRONG_ANGLES_NUMBER"));
 590       return false; break;
 591     case SMESH::SMESH_MeshEditor::EXTR_CANT_GET_TANGENT:
 592       SUIT_MessageBox::warning(this,
 593                                tr("SMESH_ERROR"),
 594                                tr("CANT_GET_TANGENT"));
 595       return false; break;
 596     case SMESH::SMESH_MeshEditor::EXTR_OK:
 597       break;
 598     }
 599   } catch (...) {
 600     return false;
 601   }
 602
 603   //mySelectionMgr->clearSelected();
 604   if ( myMeshActor )
 605     SMESH::Update( myMeshActor->getIO(), myMeshActor->GetVisibility() );
 606
 607   SMESHGUI::Modified();
 608
 609   if ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() )
 610     mySMESHGUI->updateObjBrowser(true); // new groups may appear
 611   //SMESH::UpdateView();
 612   Init(false);
 613   ConstructorsClicked(GetConstructorId());
 614   return true;
 615 }
 616
 617 //=================================================================================
 618 // function : ClickOnOk()
 619 // purpose  : Called when user presses <OK> button
 620 //=================================================================================
 621 void SMESHGUI_ExtrusionAlongPathDlg::ClickOnOk()
 622 {
 623   if (ClickOnApply())
 624     reject();
 625 }
 626
 627 //=================================================================================
 628 // function : ClickOnHelp()
 629 // purpose  :
 630 //=================================================================================
 631 void SMESHGUI_ExtrusionAlongPathDlg::ClickOnHelp()
 632 {
 633   LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
 634   if (app)
 635     app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName);
 636   else {
 637     QString platform;
 638 #ifdef WIN32
 639     platform = "winapplication";
 640 #else
 641     platform = "application";
 642 #endif
 643     SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
 644                              tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
 645                              arg(app->resourceMgr()->stringValue("ExternalBrowser",
 646                                                                  platform)).
 647                              arg(myHelpFileName));
 648   }
 649 }
 650
 651 //=================================================================================
 652 // function : reject()
 653 // purpose  : Called when dialog box is closed
 654 //=================================================================================
 655 void SMESHGUI_ExtrusionAlongPathDlg::reject()
 656 {
 657   disconnect(mySelectionMgr, 0, this, 0);
 658   mySelectionMgr->clearFilters();
 659   //mySelectionMgr->clearSelected();
 660   if (SMESH::GetCurrentVtkView()) {
 661     SMESH::RemoveFilters(); // PAL6938 -- clean all mesh entity filters
 662     SMESH::SetPointRepresentation(false);
 663     SMESH::SetPickable();
 664   }
 665   if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 666     aViewWindow->SetSelectionMode(ActorSelection);
 667   mySMESHGUI->ResetState();
 668   QDialog::reject();
 669 }
 670
 671 //=======================================================================
 672 // function : onTextChange()
 673 // purpose  :
 674 //=======================================================================
 675 void SMESHGUI_ExtrusionAlongPathDlg::onTextChange (const QString& theNewText)
 676 {
 677   QLineEdit* send = (QLineEdit*)sender();
 678
 679   // return if busy
 680   if (myBusy) return;
 681
 682   // set busy flag
 683   SetBusy sb (this);
 684
 685   if (send != StartPointLineEdit && send != ElementsLineEdit)
 686     send = ElementsLineEdit;
 687
 688   if (send == ElementsLineEdit && myEditCurrentArgument == ElementsLineEdit) {
 689     // hilight entered elements
 690     SMDS_Mesh* aMesh = 0;
 691     if (myMeshActor)
 692       aMesh = myMeshActor->GetObject()->GetMesh();
 693
 694     if (aMesh) {
 695       //mySelectionMgr->clearSelected();
 696       //mySelectionMgr->AddIObject(myMeshActor->getIO());
 697       SALOME_ListIO aList;
 698       aList.Append(myMeshActor->getIO());
 699       mySelectionMgr->setSelectedObjects(aList, false);
 700
 701       QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
 702       bool bOk;
 703       const Handle(SALOME_InteractiveObject)& anIO = myMeshActor->getIO();
 704       TColStd_MapOfInteger newIndices;
 705       for (int i = 0; i < aListId.count(); i++) {
 706         long ind = aListId[ i ].toLong(&bOk);
 707         if (bOk) {
 708           const SMDS_MeshElement* e = aMesh->FindElement(ind);
 709           if (e) {
 710             // check also type of element
 711             bool typeMatch = (Elements1dRB->isChecked() && e->GetType() == SMDSAbs_Edge) ||
 712                              (Elements2dRB->isChecked() && e->GetType() == SMDSAbs_Face);
 713             if (typeMatch)
 714               newIndices.Add(e->GetID());
 715           }
 716         }
 717       }
 718       mySelector->AddOrRemoveIndex(anIO, newIndices, false);
 719       if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 720         aViewWindow->highlight( anIO, true, true );
 721     }
 722   }
 723   else if (send == StartPointLineEdit &&
 724              myEditCurrentArgument == StartPointLineEdit) {
 725     if (!myPath->_is_nil()) {
 726       SMESH_Actor* aPathActor = SMESH::FindActorByObject(myPath);
 727       SMDS_Mesh* aMesh = 0;
 728       if (aPathActor)
 729         aMesh = aPathActor->GetObject()->GetMesh();
 730       if (aMesh) {
 731         //mySelectionMgr->clearSelected();
 732         //mySelectionMgr->AddIObject(aPathActor->getIO());
 733         SALOME_ListIO aList;
 734         aList.Append(aPathActor->getIO());
 735         mySelectionMgr->setSelectedObjects(aList, false);
 736
 737         bool bOk;
 738         long ind = theNewText.toLong(&bOk);
 739         if (bOk) {
 740           const SMDS_MeshNode* n = aMesh->FindNode(ind);
 741           if (n) {
 742             //if (!mySelectionMgr->IsIndexSelected(aPathActor->getIO(), n->GetID())) {
 743             TColStd_MapOfInteger newIndices;
 744             newIndices.Add(n->GetID());
 745             mySelector->AddOrRemoveIndex( aPathActor->getIO(), newIndices, false );
 746             if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 747               aViewWindow->highlight( aPathActor->getIO(), true, true );
 748           }
 749         }
 750       }
 751     }
 752   }
 753 }
 754
 755 //=================================================================================
 756 // function : SelectionIntoArgument()
 757 // purpose  : Called when selection as changed or other case
 758 //=================================================================================
 759 void SMESHGUI_ExtrusionAlongPathDlg::SelectionIntoArgument()
 760 {
 761   if (myBusy) return;
 762
 763   // return if dialog box is inactive
 764   if (!GroupButtons->isEnabled())
 765     return;
 766
 767   // selected objects count
 768   const SALOME_ListIO& aList = mySelector->StoredIObjects();
 769   int nbSel = aList.Extent();
 770   if (nbSel != 1)
 771     return;
 772
 773   // set busy flag
 774   SetBusy sb (this);
 775
 776   if (myEditCurrentArgument == ElementsLineEdit) {
 777     // we are now selecting mesh elements (or whole mesh/submesh/group)
 778     // reset
 779     ElementsLineEdit->clear();
 780     myMesh      = SMESH::SMESH_Mesh::_nil();
 781     myIDSource  = SMESH::SMESH_IDSource::_nil();
 782     myMeshActor = 0;
 783
 784     // try to get mesh from selection
 785     Handle(SALOME_InteractiveObject) IO = aList.First();
 786     myMesh = SMESH::GetMeshByIO(IO);
 787     if (myMesh->_is_nil())
 788       return;
 789
 790     // MakeGroups is available if there are groups
 791     if ( myMesh->NbGroups() == 0 ) {
 792       MakeGroupsCheck->setChecked(false);
 793       MakeGroupsCheck->setEnabled(false);
 794     } else {
 795       MakeGroupsCheck->setEnabled(true);
 796     }
 797     // find actor
 798     myMeshActor = SMESH::FindActorByObject(myMesh);
 799     if (!myMeshActor && !MeshCheck->isChecked())
 800       return;
 801
 802     if (MeshCheck->isChecked()) {
 803       // If "Select whole mesh, submesh or group" check box is on ->
 804       // get ID source and put it's name to the edit box
 805       QString aString;
 806       SMESH::GetNameOfSelectedIObjects(mySelectionMgr, aString);
 807
 808       myIDSource = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(IO);
 809       ElementsLineEdit->setText(aString);
 810     } else {
 811       // If "Select whole mesh, submesh or group" check box is off ->
 812       // try to get selected elements IDs
 813       QString aString;
 814       //int aNbUnits = SMESH::GetNameOfSelectedElements(mySelectionMgr, aString);
 815       SMESH::GetNameOfSelectedElements(mySelector, IO, aString);
 816       ElementsLineEdit->setText(aString);
 817     }
 818   }
 819   else if (myEditCurrentArgument == PathMeshLineEdit) {
 820     // we are now selecting path mesh
 821     // reset
 822     PathMeshLineEdit->clear();
 823     myPath = SMESH::SMESH_IDSource::_nil();
 824     StartPointLineEdit->clear();
 825
 826     // try to get mesh from selection
 827     Handle(SALOME_InteractiveObject) IO = aList.First();
 828     myPath = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(IO);
 829     if( myPath->_is_nil() )
 830       return;
 831
 832     QString aString;
 833     SMESH::GetNameOfSelectedIObjects(mySelectionMgr, aString);
 834     PathMeshLineEdit->setText(aString);
 835   }
 836   else if (myEditCurrentArgument == StartPointLineEdit) {
 837     // we are now selecting start point of path
 838     // reset
 839     StartPointLineEdit->clear();
 840
 841     // return if path mesh or path shape is not yet selected
 842     if( myPath->_is_nil() )
 843       return;
 844
 845     // try to get shape from selection
 846     Handle(SALOME_InteractiveObject) IO = aList.First();
 847
 848     SMESH_Actor* aPathActor = SMESH::FindActorByObject(myPath);
 849     if ( !aPathActor )
 850       return;
 851
 852     QString aString;
 853     int aNbUnits = SMESH::GetNameOfSelectedElements(mySelector, aPathActor->getIO(), aString);
 854     if (aNbUnits == 1)
 855       StartPointLineEdit->setText(aString.trimmed());
 856
 857   } else if (myEditCurrentArgument == XSpin) {
 858     // we are now selecting base point
 859     // reset is not performed here!
 860
 861     // return if is not enabled
 862     if (!BasePointGrp->isChecked())
 863       return;
 864
 865     // try to get shape from selection
 866     Handle(SALOME_InteractiveObject) IO = aList.First();
 867
 868     // check if geom vertex is selected
 869     GEOM::GEOM_Object_var aGeomObj = SMESH::IObjectToInterface<GEOM::GEOM_Object>(IO);
 870     TopoDS_Vertex aVertex;
 871     if (!aGeomObj->_is_nil()) {
 872       if (aGeomObj->IsShape() && GEOMBase::GetShape(aGeomObj, aVertex) && !aVertex.IsNull()) {
 873         gp_Pnt aPnt = BRep_Tool::Pnt(aVertex);
 874         XSpin->SetValue(aPnt.X());
 875         YSpin->SetValue(aPnt.Y());
 876         ZSpin->SetValue(aPnt.Z());
 877       }
 878       return;
 879     }
 880
 881     // check if smesh node is selected
 882     SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(IO);
 883     if (aMesh->_is_nil())
 884       return;
 885
 886     QString aString;
 887     int aNbUnits = SMESH::GetNameOfSelectedNodes(mySelector, IO, aString);
 888     // return if more than one node is selected
 889     if (aNbUnits != 1)
 890       return;
 891
 892     SMESH_Actor* aMeshActor = SMESH::FindActorByObject(aMesh);
 893     if (!aMeshActor)
 894       return;
 895
 896     SMDS_Mesh* mesh = aMeshActor->GetObject()->GetMesh();
 897     if (!mesh)
 898       return;
 899
 900     const SMDS_MeshNode* n = mesh->FindNode(aString.toLong());
 901     if (!n)
 902       return;
 903
 904     XSpin->SetValue(n->X());
 905     YSpin->SetValue(n->Y());
 906     ZSpin->SetValue(n->Z());
 907   }
 908   onDisplaySimulation(true);
 909 }
 910
 911 //=================================================================================
 912 // function : SetEditCurrentArgument()
 913 // purpose  :
 914 //=================================================================================
 915 void SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument()
 916 {
 917   QToolButton* send = (QToolButton*)sender();
 918   if ( sender() == BasePointGrp )
 919     send = SelectBasePointButton;
 920   if (send != SelectElementsButton   &&
 921       send != SelectPathMeshButton   &&
 922       send != SelectStartPointButton &&
 923       send != SelectBasePointButton)
 924     return;
 925   SetEditCurrentArgument(send);
 926 }
 927
 928 //=================================================================================
 929 // function : SetEditCurrentArgument()
 930 // purpose  :
 931 //=================================================================================
 932 void SMESHGUI_ExtrusionAlongPathDlg::SetEditCurrentArgument (QToolButton* button)
 933 {
 934   disconnect(mySelectionMgr, 0, this, 0);
 935   //  mySelectionMgr->clearSelected();
 936   mySelectionMgr->clearFilters();
 937   SMESH::SetPickable();
 938
 939   if (button == SelectElementsButton) {
 940     myEditCurrentArgument = ElementsLineEdit;
 941     SMESH::SetPointRepresentation(false);
 942     if (MeshCheck->isChecked()) {
 943       if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 944         aViewWindow->SetSelectionMode(ActorSelection);
 945       mySelectionMgr->installFilter(myElementsFilter);
 946     } else {
 947       if (Elements1dRB->isChecked())
 948         {
 949           if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 950             aViewWindow->SetSelectionMode(EdgeSelection);
 951         }
 952       else if (Elements2dRB->isChecked())
 953         {
 954           if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 955             aViewWindow->SetSelectionMode(FaceSelection);
 956         }
 957     }
 958   } else if (button == SelectPathMeshButton) {
 959     myEditCurrentArgument = PathMeshLineEdit;
 960     SMESH::SetPointRepresentation(false);
 961     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 962       aViewWindow->SetSelectionMode(ActorSelection);
 963     mySelectionMgr->installFilter(myPathMeshFilter);
 964   }
 965   else if (button == SelectStartPointButton) {
 966     myEditCurrentArgument = StartPointLineEdit;
 967     //if (!myPathMesh->_is_nil()) {
 968     if (!myPath->_is_nil()) {
 969       SMESH_Actor* aPathActor = SMESH::FindActorByObject(myPath);
 970       if (aPathActor) {
 971         SMESH::SetPointRepresentation(true);
 972         if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 973           aViewWindow->SetSelectionMode(NodeSelection);
 974         SMESH::SetPickable(aPathActor);
 975       }
 976     }
 977   }
 978   else if (button == SelectBasePointButton) {
 979     myEditCurrentArgument = XSpin;
 980     SMESH::SetPointRepresentation(true);
 981     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 982       aViewWindow->SetSelectionMode(NodeSelection);
 983
 984     SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter(SMESH::IDSOURCE);
 985     SMESH_NumberFilter* aVertexFilter      = new SMESH_NumberFilter ("GEOM", TopAbs_SHAPE,
 986                                                                      -1, TopAbs_VERTEX);
 987     QList<SUIT_SelectionFilter*> aListOfFilters;
 988     if (aMeshOrSubMeshFilter) aListOfFilters.append(aMeshOrSubMeshFilter);
 989     if (aVertexFilter)        aListOfFilters.append(aVertexFilter);
 990
 991     mySelectionMgr->installFilter(new SMESH_LogicalFilter
 992                                   (aListOfFilters, SMESH_LogicalFilter::LO_OR, true));
 993   }
 994
 995   if (myEditCurrentArgument && !myEditCurrentArgument->hasFocus())
 996     myEditCurrentArgument->setFocus();
 997
 998   connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
 999   SelectionIntoArgument();
1000 }
1001
1002 //=================================================================================
1003 // function : DeactivateActiveDialog()
1004 // purpose  : Deactivates this dialog
1005 //=================================================================================
1006 void SMESHGUI_ExtrusionAlongPathDlg::DeactivateActiveDialog()
1007 {
1008   if (ConstructorsBox->isEnabled()) {
1009     ConstructorsBox->setEnabled(false);
1010     GroupArguments->setEnabled(false);
1011     GroupButtons->setEnabled(false);
1012     mySMESHGUI->ResetState();
1013     mySMESHGUI->SetActiveDialogBox(0);
1014   }
1015 }
1016
1017 //=================================================================================
1018 // function : ActivateThisDialog()
1019 // purpose  : Activates this dialog
1020 //=================================================================================
1021 void SMESHGUI_ExtrusionAlongPathDlg::ActivateThisDialog()
1022 {
1023   // Emit a signal to deactivate the active dialog
1024   mySMESHGUI->EmitSignalDeactivateDialog();
1025   ConstructorsBox->setEnabled(true);
1026   GroupArguments->setEnabled(true);
1027   GroupButtons->setEnabled(true);
1028
1029   mySMESHGUI->SetActiveDialogBox(this);
1030
1031   ConstructorsClicked(GetConstructorId());
1032   SelectionIntoArgument();
1033 }
1034
1035 //=================================================================================
1036 // function : enterEvent()
1037 // purpose  : Mouse enter event
1038 //=================================================================================
1039 void SMESHGUI_ExtrusionAlongPathDlg::enterEvent (QEvent*)
1040 {
1041   if (!ConstructorsBox->isEnabled())
1042     ActivateThisDialog();
1043 }
1044
1045 //=======================================================================
1046 // function : onSelectMesh()
1047 // purpose  :
1048 //=======================================================================
1049 void SMESHGUI_ExtrusionAlongPathDlg::onSelectMesh()
1050 {
1051   bool toSelectMesh = MeshCheck->isChecked();
1052
1053   ElementsLineEdit->setReadOnly(toSelectMesh);
1054   ElementsLineEdit->setValidator(toSelectMesh ? 0 : myIdValidator);
1055   ElementsLab->setText(toSelectMesh ? tr("SMESH_NAME") : tr("SMESH_ID_ELEMENTS"));
1056   ElementsLineEdit->clear();
1057   myFilterBtn->setEnabled(!toSelectMesh);
1058
1059   SetEditCurrentArgument(SelectElementsButton);
1060 }
1061
1062 //=================================================================================
1063 // function : GetConstructorId()
1064 // purpose  :
1065 //=================================================================================
1066 int SMESHGUI_ExtrusionAlongPathDlg::GetConstructorId()
1067 {
1068   return GroupConstructors->checkedId();
1069 }
1070
1071 //=======================================================================
1072 // function : OnAngleAdded()
1073 // purpose  : Called when user adds angle to the list
1074 //=======================================================================
1075 void SMESHGUI_ExtrusionAlongPathDlg::OnAngleAdded()
1076 {
1077   QString msg;
1078   if( !AngleSpin->isValid( msg, true ) ) {
1079     QString str( tr( "SMESH_INCORRECT_INPUT" ) );
1080     if ( !msg.isEmpty() )
1081       str += "\n" + msg;
1082     SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
1083     return;
1084   }
1085   AnglesList->addItem(AngleSpin->text());
1086   myAnglesList.append(AngleSpin->GetValue());
1087
1088   updateLinearAngles();
1089 }
1090
1091 //=======================================================================
1092 // function : OnAngleRemoved()
1093 // purpose  : Called when user removes angle(s) from the list
1094 //=======================================================================
1095 void SMESHGUI_ExtrusionAlongPathDlg::OnAngleRemoved()
1096 {
1097   QList<QListWidgetItem*> aList = AnglesList->selectedItems();
1098   QListWidgetItem* anItem;
1099   foreach(anItem, aList) {
1100     myAnglesList.removeAt(AnglesList->row(anItem));
1101     delete anItem;
1102   }
1103
1104   updateLinearAngles();
1105 }
1106
1107 //=================================================================================
1108 // function : eventFilter()
1109 // purpose  : event filter ???
1110 //=================================================================================
1111 bool SMESHGUI_ExtrusionAlongPathDlg::eventFilter (QObject* object, QEvent* event)
1112 {
1113   if (event->type() == QEvent::KeyPress) {
1114     QKeyEvent* ke = (QKeyEvent*)event;
1115     if (object == AnglesList) {
1116       if (ke->key() == Qt::Key_Delete)
1117         OnAngleRemoved();
1118     }
1119   }
1120   else if (event->type() == QEvent::FocusIn) {
1121     if (object == ElementsLineEdit) {
1122       if (myEditCurrentArgument != ElementsLineEdit)
1123         SetEditCurrentArgument(SelectElementsButton);
1124     }
1125     else if (object == StartPointLineEdit) {
1126       if (myEditCurrentArgument != StartPointLineEdit)
1127         SetEditCurrentArgument(SelectStartPointButton);
1128     }
1129     else if (object == XSpin->editor() || object == YSpin->editor() || object == ZSpin->editor()) {
1130       if (myEditCurrentArgument != XSpin)
1131         SetEditCurrentArgument(SelectBasePointButton);
1132     }
1133   }
1134   return QDialog::eventFilter(object, event);
1135 }
1136
1137 //=================================================================================
1138 // function : keyPressEvent()
1139 // purpose  :
1140 //=================================================================================
1141 void SMESHGUI_ExtrusionAlongPathDlg::keyPressEvent( QKeyEvent* e )
1142 {
1143   QDialog::keyPressEvent( e );
1144   if ( e->isAccepted() )
1145     return;
1146
1147   if ( e->key() == Qt::Key_F1 ) {
1148     e->accept();
1149     ClickOnHelp();
1150   }
1151 }
1152
1153 //=================================================================================
1154 // function : setFilters()
1155 // purpose  : SLOT. Called when "Filter" button pressed.
1156 //=================================================================================
1157 void SMESHGUI_ExtrusionAlongPathDlg::setFilters()
1158 {
1159   if(myMesh->_is_nil()) {
1160     SUIT_MessageBox::critical(this,
1161                               tr("SMESH_ERROR"),
1162                               tr("NO_MESH_SELECTED"));
1163    return;
1164   }
1165   if ( !myFilterDlg )
1166   {
1167     QList<int> types;
1168     types.append( SMESH::EDGE );
1169     types.append( SMESH::FACE );
1170     myFilterDlg = new SMESHGUI_FilterDlg( mySMESHGUI, types );
1171   }
1172   myFilterDlg->Init( Elements1dRB->isChecked() ? SMESH::EDGE : SMESH::FACE );
1173
1174   myFilterDlg->SetSelection();
1175   myFilterDlg->SetMesh( myMesh );
1176   myFilterDlg->SetSourceWg( ElementsLineEdit );
1177
1178   myFilterDlg->show();
1179 }
1180
1181 //=================================================================================
1182 // function : isValid
1183 // purpose  :
1184 //=================================================================================
1185 bool SMESHGUI_ExtrusionAlongPathDlg::isValid()
1186 {
1187   QString msg;
1188   bool ok = true;
1189   ok = XSpin->isValid( msg, true ) && ok;
1190   ok = YSpin->isValid( msg, true ) && ok;
1191   ok = ZSpin->isValid( msg, true ) && ok;
1192
1193   if( !ok ) {
1194     QString str( tr( "SMESH_INCORRECT_INPUT" ) );
1195     if ( !msg.isEmpty() )
1196       str += "\n" + msg;
1197     SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
1198     return false;
1199   }
1200   return true;
1201 }
1202
1203 //=================================================================================
1204 // function : updateLinearAngles
1205 // purpose  :
1206 //=================================================================================
1207 void SMESHGUI_ExtrusionAlongPathDlg::updateLinearAngles()
1208 {
1209   bool enableLinear = true;
1210   for( int row = 0, nbRows = AnglesList->count(); row < nbRows; row++ ) {
1211     if( QListWidgetItem* anItem = AnglesList->item( row ) ) {
1212       enableLinear = false;
1213       anItem->text().toDouble(&enableLinear);
1214       if( !enableLinear )
1215         break;
1216     }
1217   }
1218   if( !enableLinear )
1219     LinearAnglesCheck->setChecked( false );
1220   LinearAnglesCheck->setEnabled( enableLinear );
1221 }
1222
1223 //=================================================================================
1224 // function : isValuesValid()
1225 // purpose  : Return true in case if values entered into dialog are valid
1226 //=================================================================================
1227 bool SMESHGUI_ExtrusionAlongPathDlg::isValuesValid() {
1228
1229   if ( (MeshCheck->isChecked() && myIDSource->_is_nil()) ||
1230        myMesh->_is_nil() ||
1231        myPath->_is_nil() )
1232     return false;
1233
1234   if(!MeshCheck->isChecked()) {
1235     QStringList aListElementsId = ElementsLineEdit->text().split(" ", QString::SkipEmptyParts);
1236     if(aListElementsId.count() <= 0)
1237       return false;
1238   }
1239
1240   bool bOk;
1241   StartPointLineEdit->text().toLong(&bOk);
1242   if (!bOk) {
1243     return false;
1244   }
1245
1246   return true;
1247 }
1248
1249
1250 //=================================================================================
1251 // function : onDisplaySimulation
1252 // purpose  : Show/Hide preview
1253 //=================================================================================
1254 void SMESHGUI_ExtrusionAlongPathDlg::onDisplaySimulation( bool toDisplayPreview ) {
1255   if (myPreviewCheckBox->isChecked() && toDisplayPreview) {
1256     if(isValid() && isValuesValid()) {
1257
1258       //Get selected elements:
1259       SMESH::long_array_var anElementsId = getSelectedElements();
1260
1261       // get angles
1262       SMESH::double_array_var anAngles = getAngles();
1263
1264       // get base point
1265       SMESH::PointStruct aBasePoint;
1266       if (BasePointGrp->isChecked()) {
1267         aBasePoint.x = XSpin->GetValue();
1268         aBasePoint.y = YSpin->GetValue();
1269         aBasePoint.z = ZSpin->GetValue();
1270       }
1271       bool bOk;
1272       long aNodeStart = StartPointLineEdit->text().toLong(&bOk);
1273       if (bOk) {
1274
1275         try {
1276           SUIT_OverrideCursor wc;
1277
1278           SMESH::SMESH_MeshEditor::Extrusion_Error retVal;
1279           SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditPreviewer();
1280           bool NeedGroups = false;
1281           SMESH::ElementType ElemType = ( GetConstructorId() == 0 ) ? SMESH::EDGE : SMESH::FACE;
1282           if( !MeshCheck->isChecked() ) {
1283             aMeshEditor->ExtrusionAlongPathX(anElementsId, myPath, aNodeStart, AnglesGrp->isChecked(),
1284                                              anAngles, LinearAnglesCheck->isChecked(),
1285                                              BasePointGrp->isChecked(), aBasePoint,
1286                                              NeedGroups, ElemType, retVal);
1287           }
1288           else {
1289             SMESH::ListOfGroups_var groups =
1290               aMeshEditor->ExtrusionAlongPathObjX(myIDSource, myPath, aNodeStart, AnglesGrp->isChecked(),
1291                                                   anAngles, LinearAnglesCheck->isChecked(),
1292                                                   BasePointGrp->isChecked(), aBasePoint,
1293                                                   NeedGroups, ElemType, retVal);
1294           }
1295
1296           if( retVal == SMESH::SMESH_MeshEditor::EXTR_OK ) {
1297             SMESH::MeshPreviewStruct_var aMeshPreviewStruct = aMeshEditor->GetPreviewData();
1298             mySimulation->SetData(aMeshPreviewStruct._retn());
1299           } else {
1300             hidePreview();
1301           }
1302
1303         } catch (...) {
1304           hidePreview();
1305         }
1306       } else {
1307         hidePreview();
1308       }
1309
1310     } else {
1311       hidePreview();
1312     }
1313   } else {
1314     hidePreview();
1315   }
1316 }
1317
1318
1319 //=================================================================================
1320 // function : getSelectedElements
1321 // purpose  : return list of the selected elements
1322 //=================================================================================
1323 SMESH::long_array_var SMESHGUI_ExtrusionAlongPathDlg::getSelectedElements() {
1324
1325   // If "Select whole mesh, submesh or group" check box is off ->
1326   // use only elements of given type selected by user
1327   SMESH::long_array_var anElementsId = new SMESH::long_array;
1328   if (!MeshCheck->isChecked()) {
1329
1330     SMDS_Mesh* aMesh;
1331     if ( myMeshActor )
1332       aMesh = myMeshActor->GetObject()->GetMesh();
1333
1334     if (aMesh) {
1335       QStringList aListElementsId = ElementsLineEdit->text().split(" ", QString::SkipEmptyParts);
1336       anElementsId = new SMESH::long_array;
1337       anElementsId->length(aListElementsId.count());
1338       bool bOk;
1339       int j = 0;
1340       for (int i = 0; i < aListElementsId.count(); i++) {
1341         long ind = aListElementsId[ i ].toLong(&bOk);
1342         if  (bOk) {
1343           const SMDS_MeshElement* e = aMesh->FindElement(ind);
1344           if (e) {
1345             bool typeMatch = (Elements1dRB->isChecked() && e->GetType() == SMDSAbs_Edge) ||
1346                              (Elements2dRB->isChecked() && e->GetType() == SMDSAbs_Face);
1347             if (typeMatch)
1348                   anElementsId[ j++ ] = ind;
1349           }
1350         }
1351       }
1352       anElementsId->length(j);
1353     }
1354   }
1355   return anElementsId;
1356 }
1357
1358 SMESH::double_array_var SMESHGUI_ExtrusionAlongPathDlg::getAngles() {
1359   SMESH::double_array_var anAngles = new SMESH::double_array;
1360   if (AnglesGrp->isChecked()) {
1361     anAngles->length(myAnglesList.count());
1362     int j = 0;
1363     for (int i = 0; i < myAnglesList.count(); i++) {
1364       double angle = myAnglesList[i];
1365       anAngles[ j++ ] = angle*M_PI/180.;
1366     }
1367     anAngles->length(j);
1368   }
1369   return anAngles;
1370 }