Fix warning

[modules/smesh.git] / src / SMESHGUI / SMESHGUI_ClippingDlg.cxx

diff --git a/src/SMESHGUI/SMESHGUI_ClippingDlg.cxx b/src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
index 993f69f283d905621447ba1439af1bf0bf128f31..c1e63059dd6daa944d8d2d516269d4f29a658621 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -105,6 +105,7 @@ void SMESH::OrientedPlane::ShallowCopy(SMESH::OrientedPlane* theOrientedPlane)
   myPlaneSource->SetOrigin(theOrientedPlane->myPlaneSource->GetOrigin());
   myPlaneSource->SetPoint1(theOrientedPlane->myPlaneSource->GetPoint1());
   myPlaneSource->SetPoint2(theOrientedPlane->myPlaneSource->GetPoint2());
+  myPlaneSource->Update();
 }
 
 SMESH::OrientedPlane::OrientedPlane(SVTK_ViewWindow* theViewWindow):
@@ -132,7 +133,7 @@ void SMESH::OrientedPlane::Init()
 
   // Create and display actor
   myMapper = vtkDataSetMapper::New();
-  myMapper->SetInput(myPlaneSource->GetOutput());
+  myMapper->SetInputConnection(myPlaneSource->GetOutputPort());
 
   myActor = SALOME_Actor::New();
   myActor->VisibilityOff();
@@ -140,17 +141,20 @@ void SMESH::OrientedPlane::Init()
   myActor->SetInfinitive(true);
   myActor->SetMapper(myMapper);
 
-  vtkFloatingPointType anRGB[3];
+  QColor ffc, bfc;
+  int delta;
+  SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "255, 170, 0|-100" ) ;
+ 
   vtkProperty* aProp = vtkProperty::New();
-  SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
-  aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
+  SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "255, 170, 0|-100" ) ;
+  aProp->SetColor(ffc.red() / 255. , ffc.green() / 255. , ffc.blue() / 255.);
   aProp->SetOpacity(0.75);
   myActor->SetProperty(aProp);
   aProp->Delete();
 
   vtkProperty* aBackProp = vtkProperty::New();
-  SMESH::GetColor( "SMESH", "backface_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 0, 255 ) );
-  aBackProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
+  bfc = Qtx::mainColorToSecondary(ffc, delta);
+  aBackProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255.);
   aBackProp->SetOpacity(0.75);
   myActor->SetBackfaceProperty(aBackProp);
   aBackProp->Delete();
@@ -208,7 +212,7 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
                                                       SVTK_ViewWindow*           theViewWindow,
                                                       SMESH::Orientation         theOrientation,
                                                       double                     theDistance,
-                                                      const vtkFloatingPointType theAngle[2])
+                                                      const double theAngle[2])
 {
   SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New(theViewWindow);
 
@@ -218,13 +222,13 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
   aPlane->SetOrientation(theOrientation);
   aPlane->SetDistance(theDistance);
 
-  vtkFloatingPointType aNormal[3];
-  vtkFloatingPointType aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
+  double aNormal[3];
+  double aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
   {
     static double aCoeff = vtkMath::Pi()/180.0;
 
-    vtkFloatingPointType anU[2] = {cos(aCoeff * theAngle[0]), cos(aCoeff * theAngle[1])};
-    vtkFloatingPointType aV[2] = {sqrt(1.0 - anU[0]*anU[0]), sqrt(1.0 - anU[1]*anU[1])};
+    double anU[2] = {cos(aCoeff * theAngle[0]), cos(aCoeff * theAngle[1])};
+    double aV[2] = {sqrt(1.0 - anU[0]*anU[0]), sqrt(1.0 - anU[1]*anU[1])};
     aV[0] = theAngle[0] > 0? aV[0]: -aV[0];
     aV[1] = theAngle[1] > 0? aV[1]: -aV[1];
 
@@ -260,8 +264,8 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
     vtkMath::Cross(aNormal,aDir[1],aDir[0]);
   }
 
-  vtkFloatingPointType aBounds[6];
-  vtkFloatingPointType anOrigin[3];
+  double aBounds[6];
+  double anOrigin[3];
 
   bool anIsOk = false;
   if( theActorList.empty() ) {
@@ -284,38 +288,38 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
   aPlane->SetNormal( aNormal );
   aPlane->SetOrigin( anOrigin );
 
-  vtkFloatingPointType aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
+  double aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
                                    ( aBounds[2] + aBounds[3] ) / 2.,
                                    ( aBounds[4] + aBounds[5] ) / 2. };
 
-  vtkFloatingPointType aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
+  double aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
                                    pow( aBounds[3] - aBounds[2], 2 ) +
                                    pow( aBounds[5] - aBounds[4], 2 ), 0.5 );
 
-  vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
+  double aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
                                        {aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
-  vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3];
+  double aParam, aPnt0[3], aPnt1[3], aPnt2[3];
 
-  vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
+  double aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
                                     aPnt[1] - aDelta[0][1] - aDelta[1][1],
                                     aPnt[2] - aDelta[0][2] - aDelta[1][2]};
-  vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0],
+  double aPnt02[3] = {aPnt01[0] + aNormal[0],
                                     aPnt01[1] + aNormal[1],
                                     aPnt01[2] + aNormal[2]};
   vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
 
-  vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
+  double aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
                                     aPnt[1] - aDelta[0][1] + aDelta[1][1],
                                     aPnt[2] - aDelta[0][2] + aDelta[1][2]};
-  vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0],
+  double aPnt12[3] = {aPnt11[0] + aNormal[0],
                                     aPnt11[1] + aNormal[1],
                                     aPnt11[2] + aNormal[2]};
   vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
 
-  vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
+  double aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
                                     aPnt[1] + aDelta[0][1] - aDelta[1][1],
                                     aPnt[2] + aDelta[0][2] - aDelta[1][2]};
-  vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0],
+  double aPnt22[3] = {aPnt21[0] + aNormal[0],
                                     aPnt21[1] + aNormal[1],
                                     aPnt21[2] + aNormal[2]};
   vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
@@ -325,6 +329,7 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
   aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
   aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
   aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
+  aPlaneSource->Update();
 
   SMESH::TActorList::iterator anIter = theActorList.begin();
   for ( ; anIter != theActorList.end(); anIter++ )
@@ -479,12 +484,12 @@ SMESHGUI_ClippingDlg::SMESHGUI_ClippingDlg( SMESHGUI* theModule, SVTK_ViewWindow
   connect(PreviewCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnPreviewToggle(bool)));
   connect(AutoApplyCheckBox, SIGNAL(toggled(bool)), this, SLOT(onAutoApply(bool)));
   connect(buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()));
-  connect(buttonCancel, SIGNAL(clicked()), this, SLOT(ClickOnCancel()));
+  connect(buttonCancel, SIGNAL(clicked()), this, SLOT(reject()));
   connect(buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnApply()));
   connect(buttonHelp, SIGNAL(clicked()), this, SLOT(ClickOnHelp()));
-  connect(mySMESHGUI, SIGNAL (SignalCloseAllDialogs()), this, SLOT(ClickOnCancel()));
+  connect(mySMESHGUI, SIGNAL (SignalCloseAllDialogs()), this, SLOT(reject()));
   /* to close dialog if study frame change */
-  connect(mySMESHGUI, SIGNAL (SignalStudyFrameChanged()), this, SLOT(ClickOnCancel()));
+  connect(mySMESHGUI, SIGNAL (SignalStudyFrameChanged()), this, SLOT(reject()));
 
   this->show();
 }
@@ -589,16 +594,17 @@ void SMESHGUI_ClippingDlg::ClickOnApply()
 void SMESHGUI_ClippingDlg::ClickOnOk()
 {
   ClickOnApply();
-  ClickOnCancel();
+  reject();
 }
 
 //=======================================================================
-// function : ClickOnCancel()
+// function : reject()
 // purpose  :
 //=======================================================================
-void SMESHGUI_ClippingDlg::ClickOnCancel()
+void SMESHGUI_ClippingDlg::reject()
 {
-  close();
+  //here we can insert actions to do at close.
+  QDialog::reject();
 }
 
 //=================================================================================
@@ -897,18 +903,18 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
   SMESH::TPlaneData aPlaneData = myPlanes[aCurPlaneIndex];
   SMESH::OrientedPlane* aPlane = aPlaneData.Plane.GetPointer();
 
-  vtkFloatingPointType aNormal[3];
+  double aNormal[3];
   SMESH::Orientation anOrientation;
-  vtkFloatingPointType aDir[3][3] = {{0, 0, 0}, {0, 0, 0}};
+  double aDir[3][3] = {{0, 0, 0}, {0, 0, 0}};
   {
     static double aCoeff = vtkMath::Pi()/180.0;
 
-    vtkFloatingPointType aRot[2] = {getRotation1(), getRotation2()};
+    double aRot[2] = {getRotation1(), getRotation2()};
     aPlane->myAngle[0] = aRot[0];
     aPlane->myAngle[1] = aRot[1];
 
-    vtkFloatingPointType anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])};
-    vtkFloatingPointType aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])};
+    double anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])};
+    double aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])};
     aV[0] = aRot[0] > 0? aV[0]: -aV[0];
     aV[1] = aRot[1] > 0? aV[1]: -aV[1];
 
@@ -955,8 +961,8 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
 
   SMESH::TActorList anActorList = aPlaneData.ActorList;
 
-  vtkFloatingPointType aBounds[6];
-  vtkFloatingPointType anOrigin[3];
+  double aBounds[6];
+  double anOrigin[3];
   bool anIsOk = SMESH::ComputeClippingPlaneParameters( anActorList,
                                                        aNormal,
                                                        getDistance(),
@@ -969,38 +975,38 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
     aPlane->SetNormal( aNormal );
     aPlane->SetOrigin( anOrigin );
 
-    vtkFloatingPointType aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
+    double aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
                                      ( aBounds[2] + aBounds[3] ) / 2.,
                                      ( aBounds[4] + aBounds[5] ) / 2. };
 
-    vtkFloatingPointType aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
+    double aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
                                      pow( aBounds[3] - aBounds[2], 2 ) +
                                      pow( aBounds[5] - aBounds[4], 2 ), 0.5 );
 
-    vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
+    double aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
                                          {aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
-    vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3];
+    double aParam, aPnt0[3], aPnt1[3], aPnt2[3];
 
-    vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
+    double aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
                                       aPnt[1] - aDelta[0][1] - aDelta[1][1],
                                       aPnt[2] - aDelta[0][2] - aDelta[1][2]};
-    vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0],
+    double aPnt02[3] = {aPnt01[0] + aNormal[0],
                                       aPnt01[1] + aNormal[1],
                                       aPnt01[2] + aNormal[2]};
     vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
 
-    vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
+    double aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
                                       aPnt[1] - aDelta[0][1] + aDelta[1][1],
                                       aPnt[2] - aDelta[0][2] + aDelta[1][2]};
-    vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0],
+    double aPnt12[3] = {aPnt11[0] + aNormal[0],
                                       aPnt11[1] + aNormal[1],
                                       aPnt11[2] + aNormal[2]};
     vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
 
-    vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
+    double aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
                                       aPnt[1] + aDelta[0][1] - aDelta[1][1],
                                       aPnt[2] + aDelta[0][2] - aDelta[1][2]};
-    vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0],
+    double aPnt22[3] = {aPnt21[0] + aNormal[0],
                                       aPnt21[1] + aNormal[1],
                                       aPnt21[2] + aNormal[2]};
     vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
@@ -1010,6 +1016,7 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
     aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
     aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
     aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
+    aPlaneSource->Update();
   }
 
   if(AutoApplyCheckBox->isChecked())
@@ -1147,8 +1154,8 @@ void SMESHGUI_ClippingDlg::dumpPlaneData() const
   for ( ; anIter1 != myPlanes.end(); anIter1++, anId++ ) {
     SMESH::TPlaneData aPlaneData = *anIter1;
     SMESH::TPlane aPlane = aPlaneData.Plane;
-    vtkFloatingPointType* aNormal = aPlane->GetNormal();
-    vtkFloatingPointType* anOrigin = aPlane->GetOrigin();
+    double* aNormal = aPlane->GetNormal();
+    double* anOrigin = aPlane->GetOrigin();
     printf( "Plane N%d:\n", anId );
     printf( "  Normal = ( %f, %f, %f )\n", aNormal[0], aNormal[1], aNormal[2] );
     printf( "  Origin = ( %f, %f, %f )\n", anOrigin[0], anOrigin[1], anOrigin[2] );