src/SMESHGUI/SMESHGUI_ExtrusionAlongPathDlg.cxx

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