]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
Salome HOME
Porting SMESH module to Qt 4
[modules/smesh.git] / src / SMESHGUI / SMESHGUI_ClippingDlg.cxx
1 // SMESH SMESHGUI : GUI for SMESH component
2 //
3 // Copyright (C) 2003  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 // File   : SMESHGUI_ClippingDlg.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
24 //
25
26 // SMESH includes
27 #include "SMESHGUI_ClippingDlg.h"
28
29 #include "SMESHGUI.h"
30 #include "SMESHGUI_Utils.h"
31 #include "SMESHGUI_VTKUtils.h"
32 #include "SMESHGUI_SpinBox.h"
33
34 #include <SMESH_Actor.h>
35 #include <SMESH_ActorUtils.h>
36
37 // SALOME GUI includes
38 #include <SUIT_Desktop.h>
39 #include <SUIT_Session.h>
40 #include <SUIT_OverrideCursor.h>
41 #include <SUIT_MessageBox.h>
42 #include <SUIT_ResourceMgr.h>
43
44 #include <SALOME_ListIO.hxx>
45
46 #include <LightApp_Application.h>
47 #include <LightApp_SelectionMgr.h>
48
49 #include <SVTK_ViewWindow.h>
50
51 // Qt includes
52 #include <QLabel>
53 #include <QPushButton>
54 #include <QComboBox>
55 #include <QCheckBox>
56 #include <QVBoxLayout>
57 #include <QHBoxLayout>
58 #include <QGridLayout>
59 #include <QGroupBox>
60 #include <QKeyEvent>
61
62 // VTK includes
63 #include <vtkMath.h>
64 #include <vtkPlane.h>
65 #include <vtkDataSet.h>
66 #include <vtkDataSetMapper.h>
67 #include <vtkPlaneSource.h>
68 #include <vtkProperty.h>
69
70 #define SPACING 6
71 #define MARGIN  11
72
73 class OrientedPlane: public vtkPlane
74 {
75   SVTK_ViewWindow* myViewWindow;
76
77   vtkDataSetMapper* myMapper;
78
79 public:
80   static OrientedPlane *New()
81   {
82     return new OrientedPlane();
83   }
84   static OrientedPlane *New(SVTK_ViewWindow* theViewWindow)
85   {
86     return new OrientedPlane(theViewWindow);
87   }
88   vtkTypeMacro (OrientedPlane, vtkPlane);
89
90   SMESH::Orientation myOrientation;
91   float myDistance;
92   double myAngle[2];
93
94   vtkPlaneSource* myPlaneSource;
95   SALOME_Actor *myActor;
96
97   void SetOrientation (SMESH::Orientation theOrientation) { myOrientation = theOrientation; }
98   SMESH::Orientation GetOrientation() { return myOrientation; }
99
100   void SetDistance (float theDistance) { myDistance = theDistance; }
101   float GetDistance() { return myDistance; }
102
103   void ShallowCopy (OrientedPlane* theOrientedPlane)
104   {
105     SetNormal(theOrientedPlane->GetNormal());
106     SetOrigin(theOrientedPlane->GetOrigin());
107
108     myOrientation = theOrientedPlane->GetOrientation();
109     myDistance = theOrientedPlane->GetDistance();
110
111     myAngle[0] = theOrientedPlane->myAngle[0];
112     myAngle[1] = theOrientedPlane->myAngle[1];
113
114     myPlaneSource->SetNormal(theOrientedPlane->myPlaneSource->GetNormal());
115     myPlaneSource->SetOrigin(theOrientedPlane->myPlaneSource->GetOrigin());
116     myPlaneSource->SetPoint1(theOrientedPlane->myPlaneSource->GetPoint1());
117     myPlaneSource->SetPoint2(theOrientedPlane->myPlaneSource->GetPoint2());
118   }
119
120 protected:
121   OrientedPlane(SVTK_ViewWindow* theViewWindow):
122     myViewWindow(theViewWindow),
123     myOrientation(SMESH::XY),
124     myDistance(0.5)
125   {
126     Init();
127     myViewWindow->AddActor(myActor);
128   }
129
130   OrientedPlane():
131     myOrientation(SMESH::XY),
132     myViewWindow(NULL),
133     myDistance(0.5)
134   {
135     Init();
136   }
137
138   void Init()
139   {
140     myPlaneSource = vtkPlaneSource::New();
141
142     myAngle[0] = myAngle[1] = 0.0;
143
144     // Create and display actor
145     myMapper = vtkDataSetMapper::New();
146     myMapper->SetInput(myPlaneSource->GetOutput());
147
148     myActor = SALOME_Actor::New();
149     myActor->VisibilityOff();
150     myActor->PickableOff();
151     myActor->SetInfinitive(true);
152     myActor->SetMapper(myMapper);
153
154     vtkFloatingPointType anRGB[3];
155     vtkProperty* aProp = vtkProperty::New();
156     SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
157     aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
158     aProp->SetOpacity(0.75);
159     myActor->SetProperty(aProp);
160     aProp->Delete();
161
162     vtkProperty* aBackProp = vtkProperty::New();
163     SMESH::GetColor( "SMESH", "backface_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 0, 255 ) );
164     aBackProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
165     aBackProp->SetOpacity(0.75);
166     myActor->SetBackfaceProperty(aBackProp);
167     aBackProp->Delete();
168   }
169
170   ~OrientedPlane(){
171     myViewWindow->RemoveActor(myActor);
172     myActor->Delete();
173     
174     myMapper->RemoveAllInputs();
175     myMapper->Delete();
176
177     // commented: porting to vtk 5.0
178     //    myPlaneSource->UnRegisterAllOutputs();
179     myPlaneSource->Delete();
180   };
181
182 private:
183   // Not implemented.
184   OrientedPlane (const OrientedPlane&);
185   void operator= (const OrientedPlane&);
186
187 };
188
189 struct TSetVisiblity {
190   TSetVisiblity(int theIsVisible): myIsVisible(theIsVisible){}
191   void operator()(SMESH::TVTKPlane& theOrientedPlane){
192     theOrientedPlane->myActor->SetVisibility(myIsVisible);
193   }
194   int myIsVisible;
195 };
196
197 //=================================================================================
198 // class    : SMESHGUI_ClippingDlg()
199 // purpose  :
200 //
201 //=================================================================================
202 SMESHGUI_ClippingDlg::SMESHGUI_ClippingDlg( SMESHGUI* theModule ):
203   QDialog( SMESH::GetDesktop(theModule) ),
204   mySelector(SMESH::GetViewWindow(theModule)->GetSelector()),
205   mySelectionMgr(SMESH::GetSelectionMgr(theModule)),
206   mySMESHGUI(theModule)
207 {
208   setModal( false );
209   setAttribute( Qt::WA_DeleteOnClose, true );
210   setWindowTitle(tr("SMESH_CLIPPING_TITLE"));
211   setSizeGripEnabled(true);
212
213   QVBoxLayout* SMESHGUI_ClippingDlgLayout = new QVBoxLayout(this);
214   SMESHGUI_ClippingDlgLayout->setSpacing(SPACING);
215   SMESHGUI_ClippingDlgLayout->setMargin(MARGIN);
216
217   // Controls for selecting, creating, deleting planes
218   QGroupBox* GroupPlanes = new QGroupBox(tr("Clipping planes"), this);
219   QHBoxLayout* GroupPlanesLayout = new QHBoxLayout(GroupPlanes);
220   GroupPlanesLayout->setSpacing(SPACING);
221   GroupPlanesLayout->setMargin(MARGIN);
222
223   ComboBoxPlanes = new QComboBox(GroupPlanes);
224
225   buttonNew = new QPushButton(tr("SMESH_BUT_NEW"), GroupPlanes);
226
227   buttonDelete = new QPushButton(tr("SMESH_BUT_DELETE"), GroupPlanes);
228
229   GroupPlanesLayout->addWidget(ComboBoxPlanes);
230   GroupPlanesLayout->addStretch();
231   GroupPlanesLayout->addWidget(buttonNew);
232   GroupPlanesLayout->addWidget(buttonDelete);
233
234   // Controls for defining plane parameters
235   QGroupBox* GroupParameters = new QGroupBox(tr("SMESH_PARAMETERS"), this);
236   QGridLayout* GroupParametersLayout = new QGridLayout(GroupParameters);
237   GroupParametersLayout->setSpacing(SPACING);
238   GroupParametersLayout->setMargin(MARGIN);
239
240   TextLabelOrientation = new QLabel(tr("SMESH_ORIENTATION"), GroupParameters);
241
242   ComboBoxOrientation = new QComboBox(GroupParameters);
243
244   TextLabelDistance = new QLabel(tr("SMESH_DISTANCE"), GroupParameters);
245
246   SpinBoxDistance = new SMESHGUI_SpinBox(GroupParameters);
247
248   TextLabelRot1 = new QLabel(tr("Rotation around X (Y to Z):"), GroupParameters);
249
250   SpinBoxRot1 = new SMESHGUI_SpinBox(GroupParameters);
251
252   TextLabelRot2 = new QLabel(tr("Rotation around Y (X to Z):"), GroupParameters);
253
254   SpinBoxRot2 = new SMESHGUI_SpinBox(GroupParameters);
255
256   PreviewCheckBox = new QCheckBox(tr("Show preview"), GroupParameters);
257   PreviewCheckBox->setChecked(true);
258
259   AutoApplyCheckBox = new QCheckBox(tr("Auto Apply"), GroupParameters);
260   AutoApplyCheckBox->setChecked(false);
261
262   GroupParametersLayout->addWidget(TextLabelOrientation, 0, 0);
263   GroupParametersLayout->addWidget(ComboBoxOrientation,  0, 1);
264   GroupParametersLayout->addWidget(TextLabelDistance,    1, 0);
265   GroupParametersLayout->addWidget(SpinBoxDistance,      1, 1);
266   GroupParametersLayout->addWidget(TextLabelRot1,        2, 0);
267   GroupParametersLayout->addWidget(SpinBoxRot1,          2, 1);
268   GroupParametersLayout->addWidget(TextLabelRot2,        3, 0);
269   GroupParametersLayout->addWidget(SpinBoxRot2,          3, 1);
270   GroupParametersLayout->addWidget(PreviewCheckBox,      4, 0);
271   GroupParametersLayout->addWidget(AutoApplyCheckBox,    4, 1);
272
273   // Controls for "Ok", "Apply" and "Close" button
274   QGroupBox* GroupButtons = new QGroupBox(this);
275   QHBoxLayout* GroupButtonsLayout = new QHBoxLayout(GroupButtons);
276   GroupButtonsLayout->setSpacing(SPACING);
277   GroupButtonsLayout->setMargin(MARGIN);
278   
279   buttonOk = new QPushButton(tr("SMESH_BUT_OK"), GroupButtons);
280   buttonOk->setAutoDefault(true);
281   buttonOk->setDefault(true);
282   buttonApply = new QPushButton(tr("SMESH_BUT_APPLY"), GroupButtons);
283   buttonApply->setAutoDefault(true);
284   buttonCancel = new QPushButton(tr("SMESH_BUT_CLOSE"), GroupButtons);
285   buttonCancel->setAutoDefault(true);
286   buttonHelp = new QPushButton(tr("SMESH_BUT_HELP"), GroupButtons);
287   buttonHelp->setAutoDefault(true);
288   GroupButtonsLayout->addWidget(buttonOk);
289   GroupButtonsLayout->addSpacing(10);
290   GroupButtonsLayout->addWidget(buttonApply);
291   GroupButtonsLayout->addSpacing(10);
292   GroupButtonsLayout->addStretch();
293   GroupButtonsLayout->addWidget(buttonCancel);
294   GroupButtonsLayout->addWidget(buttonHelp);
295
296   SMESHGUI_ClippingDlgLayout->addWidget(GroupPlanes);
297   SMESHGUI_ClippingDlgLayout->addWidget(GroupParameters);
298   SMESHGUI_ClippingDlgLayout->addWidget(GroupButtons);
299
300   // Initial state
301   SpinBoxDistance->RangeStepAndValidator(0.0, 1.0, 0.01, 3);
302   SpinBoxRot1->RangeStepAndValidator(-180.0, 180.0, 1, 3);
303   SpinBoxRot2->RangeStepAndValidator(-180.0, 180.0, 1, 3);
304
305   ComboBoxOrientation->addItem(tr("|| X-Y"));
306   ComboBoxOrientation->addItem(tr("|| Y-Z"));
307   ComboBoxOrientation->addItem(tr("|| Z-X"));
308
309   SpinBoxDistance->SetValue(0.5);
310
311   myActor = 0;
312   myIsSelectPlane = false;
313   onSelectionChanged();
314
315   myHelpFileName = "clipping_page.html";
316
317   // signals and slots connections :
318   connect(ComboBoxPlanes, SIGNAL(activated(int)), this, SLOT(onSelectPlane(int)));
319   connect(buttonNew, SIGNAL(clicked()), this, SLOT(ClickOnNew()));
320   connect(buttonDelete, SIGNAL(clicked()), this, SLOT(ClickOnDelete()));
321   connect(ComboBoxOrientation, SIGNAL(activated(int)), this, SLOT(onSelectOrientation(int)));
322   connect(SpinBoxDistance, SIGNAL(valueChanged(double)), this, SLOT(SetCurrentPlaneParam()));
323   connect(SpinBoxRot1, SIGNAL(valueChanged(double)), this, SLOT(SetCurrentPlaneParam()));
324   connect(SpinBoxRot2, SIGNAL(valueChanged(double)), this, SLOT(SetCurrentPlaneParam()));
325   connect(PreviewCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnPreviewToggle(bool)));
326   connect(AutoApplyCheckBox, SIGNAL(toggled(bool)), this, SLOT(ClickOnApply()));
327   connect(buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()));
328   connect(buttonCancel, SIGNAL(clicked()), this, SLOT(ClickOnCancel()));
329   connect(buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnApply()));
330   connect(buttonHelp, SIGNAL(clicked()), this, SLOT(ClickOnHelp()));
331   connect(mySMESHGUI, SIGNAL (SignalCloseAllDialogs()), this, SLOT(ClickOnOk()));
332   connect(mySelectionMgr,  SIGNAL(currentSelectionChanged()), this, SLOT(onSelectionChanged()));
333   /* to close dialog if study frame change */
334   connect(mySMESHGUI, SIGNAL (SignalStudyFrameChanged()), this, SLOT(ClickOnCancel()));
335
336   this->show();
337 }
338
339 //=================================================================================
340 // function : ~SMESHGUI_ClippingDlg()
341 // purpose  :
342 //=================================================================================
343 SMESHGUI_ClippingDlg::~SMESHGUI_ClippingDlg()
344 {
345   // no need to delete child widgets, Qt does it all for us
346   std::for_each(myPlanes.begin(),myPlanes.end(),TSetVisiblity(false));
347   SMESH::RenderViewWindow(SMESH::GetViewWindow(mySMESHGUI));
348 }
349
350 double SMESHGUI_ClippingDlg::getDistance() const
351 {
352   return SpinBoxDistance->GetValue();
353 }
354
355 void SMESHGUI_ClippingDlg::setDistance( const double theDistance )
356 {
357   SpinBoxDistance->SetValue( theDistance );
358 }
359
360 double SMESHGUI_ClippingDlg::getRotation1() const
361 {
362   return SpinBoxRot1->GetValue();
363 }
364
365 double SMESHGUI_ClippingDlg::getRotation2() const
366 {
367   return SpinBoxRot2->GetValue();
368 }
369
370 //=======================================================================
371 // function : ClickOnApply()
372 // purpose  :
373 //=======================================================================
374 void SMESHGUI_ClippingDlg::ClickOnApply()
375 {
376   if (!myActor)
377     return;
378
379   if (SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow(mySMESHGUI)) {
380     SUIT_OverrideCursor wc;
381     
382     QWidget *aCurrWid = this->focusWidget();
383     aCurrWid->clearFocus();
384     aCurrWid->setFocus();
385
386     myActor->RemoveAllClippingPlanes();
387
388     SMESH::TPlanes::iterator anIter = myPlanes.begin();
389     for ( ; anIter != myPlanes.end(); anIter++) {
390       OrientedPlane* anOrientedPlane = OrientedPlane::New(aViewWindow);
391       anOrientedPlane->ShallowCopy(anIter->GetPointer());
392       myActor->AddClippingPlane(anOrientedPlane);
393       anOrientedPlane->Delete();
394     }
395
396     SMESH::RenderViewWindow(aViewWindow);
397   }
398 }
399
400 //=======================================================================
401 // function : ClickOnOk()
402 // purpose  :
403 //=======================================================================
404 void SMESHGUI_ClippingDlg::ClickOnOk()
405 {
406   ClickOnApply();
407   ClickOnCancel();
408 }
409
410 //=======================================================================
411 // function : ClickOnCancel()
412 // purpose  :
413 //=======================================================================
414 void SMESHGUI_ClippingDlg::ClickOnCancel()
415 {
416   close();
417 }
418
419 //=================================================================================
420 // function : ClickOnHelp()
421 // purpose  :
422 //=================================================================================
423 void SMESHGUI_ClippingDlg::ClickOnHelp()
424 {
425   LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
426   if (app) 
427     app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName);
428   else {
429                 QString platform;
430 #ifdef WIN32
431                 platform = "winapplication";
432 #else
433                 platform = "application";
434 #endif
435     SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
436                              tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
437                              arg(app->resourceMgr()->stringValue("ExternalBrowser", 
438                                                                  platform)).
439                              arg(myHelpFileName));
440   }
441 }
442
443 //=================================================================================
444 // function : onSelectionChanged()
445 // purpose  : Called when selection is changed
446 //=================================================================================
447 void SMESHGUI_ClippingDlg::onSelectionChanged()
448 {
449   if (SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow(mySMESHGUI)) {
450     const SALOME_ListIO& aList = mySelector->StoredIObjects();
451     if (aList.Extent() > 0) {
452       Handle(SALOME_InteractiveObject) IOS = aList.First();
453       myActor = SMESH::FindActorByEntry(IOS->getEntry());
454       if (myActor) {
455         std::for_each(myPlanes.begin(),myPlanes.end(),TSetVisiblity(false));
456         myPlanes.clear();
457
458         vtkIdType anId = 0, anEnd = myActor->GetNumberOfClippingPlanes();
459         for ( ; anId < anEnd; anId++) {
460           if (vtkImplicitFunction* aFunction = myActor->GetClippingPlane(anId)) {
461             if(OrientedPlane* aPlane = OrientedPlane::SafeDownCast(aFunction)){
462               OrientedPlane* anOrientedPlane = OrientedPlane::New(aViewWindow);
463               SMESH::TVTKPlane aTVTKPlane(anOrientedPlane);
464               anOrientedPlane->Delete();
465               aTVTKPlane->ShallowCopy(aPlane);
466               myPlanes.push_back(aTVTKPlane);
467             }
468           }
469         }
470
471         std::for_each(myPlanes.begin(),myPlanes.end(),
472                       TSetVisiblity(PreviewCheckBox->isChecked()));
473       }
474     }
475     SMESH::RenderViewWindow(aViewWindow);
476   }
477   Sinchronize();
478 }
479
480 //=======================================================================
481 // function : onSelectPlane()
482 // purpose  :
483 //=======================================================================
484 void SMESHGUI_ClippingDlg::onSelectPlane (int theIndex)
485 {
486   if (!myActor || myPlanes.empty())
487     return;
488
489   OrientedPlane* aPlane = myPlanes[theIndex].GetPointer();
490
491   // Orientation
492   SMESH::Orientation anOrientation = aPlane->GetOrientation();
493
494   // Rotations
495   double aRot[2] = {aPlane->myAngle[0], aPlane->myAngle[1]};
496
497   // Set plane parameters in the dialog
498   myIsSelectPlane = true;
499   setDistance(aPlane->GetDistance());
500   setRotation(aRot[0], aRot[1]);
501   switch (anOrientation) {
502   case SMESH::XY:
503     ComboBoxOrientation->setCurrentIndex(0);
504     onSelectOrientation(0);
505     break;
506   case SMESH::YZ:
507     ComboBoxOrientation->setCurrentIndex(1);
508     onSelectOrientation(1);
509     break;
510   case SMESH::ZX:
511     ComboBoxOrientation->setCurrentIndex(2);
512     onSelectOrientation(2);
513     break;
514   }
515   myIsSelectPlane = false;
516 }
517
518 //=======================================================================
519 // function : ClickOnNew()
520 // purpose  :
521 //=======================================================================
522 void SMESHGUI_ClippingDlg::ClickOnNew()
523 {
524   if (!myActor)
525     return;
526
527   if(SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow(mySMESHGUI)){
528     OrientedPlane* aPlane = OrientedPlane::New(aViewWindow);
529     SMESH::TVTKPlane aTVTKPlane(aPlane);
530     myPlanes.push_back(aTVTKPlane);
531
532     if (PreviewCheckBox->isChecked())
533       aTVTKPlane->myActor->VisibilityOn();
534     
535     Sinchronize();
536     SetCurrentPlaneParam();
537   }
538 }
539
540 //=======================================================================
541 // function : ClickOnDelete()
542 // purpose  :
543 //=======================================================================
544 void SMESHGUI_ClippingDlg::ClickOnDelete()
545 {
546   if (!myActor || myPlanes.empty())
547     return;
548
549   int aPlaneIndex = ComboBoxPlanes->currentIndex();
550
551   SMESH::TPlanes::iterator anIter = myPlanes.begin() + aPlaneIndex;
552   anIter->GetPointer()->myActor->SetVisibility(false);
553   myPlanes.erase(anIter);
554
555   if(AutoApplyCheckBox->isChecked())
556     ClickOnApply();
557
558   Sinchronize();
559   SMESH::RenderViewWindow(SMESH::GetCurrentVtkView());
560 }
561
562 //=======================================================================
563 // function : onSelectOrientation()
564 // purpose  :
565 //=======================================================================
566 void SMESHGUI_ClippingDlg::onSelectOrientation (int theItem)
567 {
568   if (myPlanes.empty())
569     return;
570
571   if      (theItem == 0) {
572     TextLabelRot1->setText(tr("Rotation around X (Y to Z):"));
573     TextLabelRot2->setText(tr("Rotation around Y (X to Z):"));
574   }
575   else if (theItem == 1) {
576     TextLabelRot1->setText(tr("Rotation around Y (Z to X):"));
577     TextLabelRot2->setText(tr("Rotation around Z (Y to X):"));
578   }
579   else if (theItem == 2) {
580     TextLabelRot1->setText(tr("Rotation around Z (X to Y):"));
581     TextLabelRot2->setText(tr("Rotation around X (Z to Y):"));
582   }
583
584   if((QComboBox*)sender() == ComboBoxOrientation)
585     SetCurrentPlaneParam();
586 }
587
588 //=======================================================================
589 // function : Sinchronize()
590 // purpose  :
591 //=======================================================================
592 void SMESHGUI_ClippingDlg::Sinchronize()
593 {
594   int aNbPlanes = myPlanes.size();
595   ComboBoxPlanes->clear();
596
597   QString aName;
598   for(int i = 1; i<=aNbPlanes; i++) {
599     aName = QString(tr("Plane# %1")).arg(i);
600     ComboBoxPlanes->addItem(aName);
601   }
602
603   int aPos = ComboBoxPlanes->count() - 1;
604   ComboBoxPlanes->setCurrentIndex(aPos);
605
606   bool anIsControlsEnable = (aPos >= 0);
607   if (anIsControlsEnable) {
608     onSelectPlane(aPos);
609   } else {
610     ComboBoxPlanes->addItem(tr("No planes"));
611     SpinBoxRot1->SetValue(0.0);
612     SpinBoxRot2->SetValue(0.0);
613     SpinBoxDistance->SetValue(0.5);
614   }
615
616   buttonDelete->setEnabled(anIsControlsEnable);
617   buttonApply->setEnabled(anIsControlsEnable);
618   PreviewCheckBox->setEnabled(anIsControlsEnable);
619   AutoApplyCheckBox->setEnabled(anIsControlsEnable);
620   ComboBoxOrientation->setEnabled(anIsControlsEnable);
621   SpinBoxDistance->setEnabled(anIsControlsEnable);
622   SpinBoxRot1->setEnabled(anIsControlsEnable);
623   SpinBoxRot2->setEnabled(anIsControlsEnable);
624 }
625
626 //=======================================================================
627 // function : setRotation()
628 // purpose  :
629 //=======================================================================
630 void SMESHGUI_ClippingDlg::setRotation (const double theRot1, const double theRot2)
631 {
632   SpinBoxRot1->SetValue(theRot1);
633   SpinBoxRot2->SetValue(theRot2);
634 }
635
636 //=======================================================================
637 // function : SetCurrentPlaneParam()
638 // purpose  :
639 //=======================================================================
640 void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
641 {
642   if (myPlanes.empty() || myIsSelectPlane)
643     return;
644
645   int aCurPlaneIndex = ComboBoxPlanes->currentIndex();
646
647   OrientedPlane* aPlane = myPlanes[aCurPlaneIndex].GetPointer();
648
649   vtkFloatingPointType aNormal[3];
650   SMESH::Orientation anOrientation;
651   vtkFloatingPointType aDir[3][3] = {{0, 0, 0}, {0, 0, 0}};
652   {
653     static double aCoeff = vtkMath::Pi()/180.0;
654
655     vtkFloatingPointType aRot[2] = {getRotation1(), getRotation2()};
656     aPlane->myAngle[0] = aRot[0];
657     aPlane->myAngle[1] = aRot[1];
658
659     vtkFloatingPointType anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])};
660     vtkFloatingPointType aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])};
661     aV[0] = aRot[0] > 0? aV[0]: -aV[0];
662     aV[1] = aRot[1] > 0? aV[1]: -aV[1];
663
664     switch (ComboBoxOrientation->currentIndex()) {
665     case 0:
666       anOrientation = SMESH::XY;
667
668       aDir[0][1] = anU[0];
669       aDir[0][2] = aV[0];
670
671       aDir[1][0] = anU[1];
672       aDir[1][2] = aV[1];
673
674       break;
675     case 1:
676       anOrientation = SMESH::YZ;
677
678       aDir[0][2] = anU[0];
679       aDir[0][0] = aV[0];
680
681       aDir[1][1] = anU[1];
682       aDir[1][0] = aV[1];
683
684       break;
685     case 2:
686       anOrientation = SMESH::ZX;
687
688       aDir[0][0] = anU[0];
689       aDir[0][1] = aV[0];
690
691       aDir[1][2] = anU[1];
692       aDir[1][1] = aV[1];
693
694       break;
695     }
696
697     vtkMath::Cross(aDir[1],aDir[0],aNormal);
698     vtkMath::Normalize(aNormal);
699     vtkMath::Cross(aNormal,aDir[1],aDir[0]);
700   }
701
702   aPlane->SetOrientation(anOrientation);
703   aPlane->SetDistance(getDistance());
704
705   myActor->SetPlaneParam(aNormal, getDistance(), aPlane);
706
707   vtkDataSet* aDataSet = myActor->GetInput();
708   vtkFloatingPointType *aPnt = aDataSet->GetCenter();
709
710   vtkFloatingPointType* anOrigin = aPlane->GetOrigin();
711   vtkFloatingPointType aDel = aDataSet->GetLength()/2.0;
712
713   vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
714                                        {aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
715   vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3];
716
717   vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
718                                     aPnt[1] - aDelta[0][1] - aDelta[1][1],
719                                     aPnt[2] - aDelta[0][2] - aDelta[1][2]};
720   vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0],
721                                     aPnt01[1] + aNormal[1],
722                                     aPnt01[2] + aNormal[2]};
723   vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
724
725   vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
726                                     aPnt[1] - aDelta[0][1] + aDelta[1][1],
727                                     aPnt[2] - aDelta[0][2] + aDelta[1][2]};
728   vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0],
729                                     aPnt11[1] + aNormal[1],
730                                     aPnt11[2] + aNormal[2]};
731   vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
732
733   vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
734                                     aPnt[1] + aDelta[0][1] - aDelta[1][1],
735                                     aPnt[2] + aDelta[0][2] - aDelta[1][2]};
736   vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0],
737                                     aPnt21[1] + aNormal[1],
738                                     aPnt21[2] + aNormal[2]};
739   vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
740
741   vtkPlaneSource* aPlaneSource = aPlane->myPlaneSource;
742   aPlaneSource->SetNormal(aNormal[0],aNormal[1],aNormal[2]);
743   aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
744   aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
745   aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
746
747   if(AutoApplyCheckBox->isChecked())
748     ClickOnApply();
749
750   SMESH::RenderViewWindow(SMESH::GetCurrentVtkView());
751 }
752
753 //=======================================================================
754 // function : OnPreviewToggle()
755 // purpose  :
756 //=======================================================================
757 void SMESHGUI_ClippingDlg::OnPreviewToggle (bool theIsToggled)
758 {
759   std::for_each(myPlanes.begin(),myPlanes.end(),TSetVisiblity(theIsToggled));
760   SMESH::RenderViewWindow(SMESH::GetCurrentVtkView());
761 }
762
763 //=================================================================================
764 // function : keyPressEvent()
765 // purpose  :
766 //=================================================================================
767 void SMESHGUI_ClippingDlg::keyPressEvent( QKeyEvent* e )
768 {
769   QDialog::keyPressEvent( e );
770   if ( e->isAccepted() )
771     return;
772
773   if ( e->key() == Qt::Key_F1 ) {
774     e->accept();
775     ClickOnHelp();
776   }
777 }