src/HOMARDGUI/MonCreateBoundaryAn.cxx

   1 // Copyright (C) 2011-2016  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "MonCreateBoundaryAn.h"
  21 #include "MonCreateCase.h"
  22
  23 #include <QFileDialog>
  24 #include <QMessageBox>
  25
  26 #include "SalomeApp_Tools.h"
  27 #include "HOMARDGUI_Utils.h"
  28 #include "HomardQtCommun.h"
  29 #include <utilities.h>
  30
  31 #include <SUIT_Desktop.h>
  32 #include <SUIT_MessageBox.h>
  33 #include <SUIT_ResourceMgr.h>
  34 #include <SUIT_Session.h>
  35 #include <SUIT_ViewManager.h>
  36
  37 #include "math.h"
  38 #define PI 3.141592653589793
  39
  40 using namespace std;
  41 // ------------------------------------------------------------------------------------------------------------------------
  42 MonCreateBoundaryAn::MonCreateBoundaryAn(MonCreateCase* parent, bool modal,
  43                              HOMARD::HOMARD_Gen_var myHomardGen0,
  44                              QString caseName) :
  45 // ------------------------------------------------------------------------------------------------------------------------------
  46 /* Constructs a MonCreateBoundaryAn
  47    appele pour une vraie creation
  48    initialise un cylindre et non une sphere
  49 */
  50     QDialog(0), Ui_CreateBoundaryAn(),
  51     _parent(parent),
  52     _aName (""),
  53     _aCaseName(caseName),
  54     _Xmin(0), _Xmax(0), _Xincr(0), _Ymin(0), _Ymax(0), _Yincr(0), _Zmin(0), _Zmax(0), _Zincr(0), _DMax(0),
  55     _Type(1),
  56     _BoundaryAnXcentre(0), _BoundaryAnYcentre(0), _BoundaryAnZcentre(0), _BoundaryAnRayon(0),
  57     _BoundaryAnXaxis(0), _BoundaryAnYaxis(0), _BoundaryAnZaxis(0),
  58     _Xcentre(0), _Ycentre(0), _Zcentre(0), _Rayon(0),
  59     _BoundaryAnXcone1(0), _BoundaryAnYcone1(0), _BoundaryAnZcone1(0), _BoundaryAnRayon1(0),
  60     _BoundaryAnXcone2(0), _BoundaryAnYcone2(0), _BoundaryAnZcone2(0), _BoundaryAnRayon2(0),
  61     _BoundaryAnXaxisCone(0), _BoundaryAnYaxisCone(0), _BoundaryAnZaxisCone(0),
  62     _BoundaryAngle(0),
  63     _BoundaryAnToreXcentre(0), _BoundaryAnToreYcentre(0), _BoundaryAnToreZcentre(0),
  64     _BoundaryAnToreXaxe(0), _BoundaryAnToreYaxe(0), _BoundaryAnToreZaxe(0),
  65     _BoundaryAnToreRRev(0), _BoundaryAnToreRPri(0),
  66     Chgt (false)
  67     {
  68       MESSAGE("Constructeur") ;
  69       myHomardGen=HOMARD::HOMARD_Gen::_duplicate(myHomardGen0);
  70       setupUi(this);
  71       setModal(modal);
  72
  73     //  Gestion des icones
  74       QPixmap pix ;
  75       QIcon IS ;
  76       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  77       pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
  78       IS=QIcon(pix);
  79       RBSphere->setIcon(IS);
  80       pix = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
  81       IS=QIcon(pix);
  82       RBCylindre->setIcon(IS);
  83       pix = resMgr->loadPixmap( "HOMARD", "cone.png" );
  84       IS=QIcon(pix);
  85       RBCone->setIcon(IS);
  86       pix = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
  87       IS=QIcon(pix);
  88       RB_Def_angle->setIcon(IS);
  89       pix = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
  90       IS=QIcon(pix);
  91       RB_Def_radius->setIcon(IS);
  92       pix = resMgr->loadPixmap( "HOMARD", "toruspointvector.png" );
  93       IS=QIcon(pix);
  94       RBTore->setIcon(IS);
  95
  96       InitConnect( );
  97
  98       SetNewName() ;
  99       InitValBoundaryAn();          // Cherche les valeurs de la boite englobante le maillage
 100       InitMinMax();                 // Initialise les bornes des boutons
 101       SetCylinder();                // Propose un cylindre en premier choix
 102     }
 103 // --------------------------------------------------------------------------------------------------------------
 104 MonCreateBoundaryAn::MonCreateBoundaryAn(MonCreateCase* parent,
 105                              HOMARD::HOMARD_Gen_var myHomardGen0,
 106                              QString caseName):
 107 // --------------------------------------------------------------------------------------------------------------
 108 //
 109     QDialog(0), Ui_CreateBoundaryAn(),
 110      myHomardGen(myHomardGen0),
 111     _parent(parent),
 112     _aName (""),
 113     _aCaseName(caseName),
 114     _Type(1),
 115     _BoundaryAnXcentre(0), _BoundaryAnYcentre(0), _BoundaryAnZcentre(0), _BoundaryAnRayon(0),
 116     _BoundaryAnXaxis(0), _BoundaryAnYaxis(0), _BoundaryAnZaxis(0),
 117     // Pour affichage lors de l edition d une BoundaryAn sans nom de Cas
 118     _Xcentre(0), _Ycentre(0), _Zcentre(0), _Rayon(0),
 119     _Xmin(1), _Xmax(1), _Xincr(1), _Ymin(1), _Ymax(1), _Yincr(1), _Zmin(1), _Zmax(1), _Zincr(1), _DMax(1),
 120     Chgt (false)
 121     {
 122   //  MESSAGE("Debut de  MonCreateBoundaryAn")
 123       setupUi(this);
 124       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 125       QPixmap pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
 126       QIcon IS=QIcon(pix);
 127       RBSphere->setIcon(IS);
 128       QPixmap pix2 = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
 129       QIcon IS2=QIcon(pix2);
 130       RBCylindre->setIcon(IS2);
 131       QPixmap pix3 = resMgr->loadPixmap( "HOMARD", "cone.png" );
 132       QIcon IS3=QIcon(pix3);
 133       RBCone->setIcon(IS3);
 134       QPixmap pix4 = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
 135       QIcon IS4=QIcon(pix4);
 136       RB_Def_angle->setIcon(IS4);
 137       QPixmap pix5 = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
 138       QIcon IS5=QIcon(pix5);
 139       RB_Def_radius->setIcon(IS5);
 140       setModal(true);
 141       InitConnect();
 142     }
 143
 144 // ------------------------------------------------------------------------
 145 MonCreateBoundaryAn::~MonCreateBoundaryAn()
 146 // ------------------------------------------------------------------------
 147 {
 148     // no need to delete child widgets, Qt does it all for us
 149 }
 150 // ------------------------------------------------------------------------
 151 void MonCreateBoundaryAn::InitConnect()
 152 // ------------------------------------------------------------------------
 153 {
 154     connect( RBCylindre,    SIGNAL(clicked()) , this, SLOT(SetCylinder()) ) ;
 155     connect( RBSphere,      SIGNAL(clicked()) , this, SLOT(SetSphere()) ) ;
 156     connect( RBCone,        SIGNAL(clicked()) , this, SLOT(SetCone()) ) ;
 157     connect( RB_Def_radius, SIGNAL(clicked()) , this, SLOT(SetConeR()) );
 158     connect( RB_Def_angle,  SIGNAL(clicked()) , this, SLOT(SetConeA()) );
 159     connect( RBTore,        SIGNAL(clicked()) , this, SLOT(SetTore()) ) ;
 160     connect( buttonOk,     SIGNAL( pressed() ), this, SLOT( PushOnOK() ) );
 161     connect( buttonApply,  SIGNAL( pressed() ), this, SLOT( PushOnApply() ) );
 162     connect( buttonCancel, SIGNAL( pressed() ), this, SLOT( close() ) );
 163     connect( buttonHelp,   SIGNAL( pressed() ), this, SLOT( PushOnHelp() ) );
 164 }
 165 // ------------------------------------------------------------------------
 166 void MonCreateBoundaryAn::InitValBoundaryAn()
 167 // ------------------------------------------------------------------------
 168 {
 169 //
 170 //  1. Les coordonnees extremes du maillage
 171 //
 172     if (_aCaseName == QString("")) { return; }
 173
 174     HOMARD::HOMARD_Cas_var aCas = myHomardGen->GetCase(_aCaseName.toStdString().c_str());
 175     HOMARD::extrema_var  MesExtremes = aCas->GetBoundingBox();
 176     int num = MesExtremes->length() ;
 177     ASSERT(num == 10);
 178     _Xmin=MesExtremes[0]; _Xmax=MesExtremes[1]; _Xincr=MesExtremes[2];
 179     _Ymin=MesExtremes[3]; _Ymax=MesExtremes[4]; _Yincr=MesExtremes[5];
 180     _Zmin=MesExtremes[6]; _Zmax=MesExtremes[7]; _Zincr=MesExtremes[8];
 181     _DMax=MesExtremes[9];
 182      MESSAGE ("_Xmin : " << _Xmin << " _Xmax : " << _Xmax << " _Xincr : " << _Xincr ) ;
 183      MESSAGE ("_Ymin : " << _Ymin << " _Ymax : " << _Ymax << " _Yincr : " << _Yincr ) ;
 184      MESSAGE ("_Zmin : " << _Zmin << " _Zmax : " << _Zmax << " _Zincr : " << _Zincr) ;
 185      MESSAGE ("_DMax : " << _DMax);
 186
 187 //  2. Caracteristiques des frontieres
 188 // en X
 189     _Xcentre=(_Xmin + _Xmax)/2.;
 190 // en Y
 191     _Ycentre=(_Ymin + _Ymax)/2.;
 192 // en Z
 193     _Zcentre=(_Zmin + _Zmax)/2.;
 194 // Rayon
 195     _Rayon= _DMax/4.;
 196 }
 197
 198 // ------------------------------------------------------------------------
 199 void MonCreateBoundaryAn::InitMinMax()
 200 // ------------------------------------------------------------------------
 201 {
 202   // Cylindre
 203   // . X du centre
 204   SpinBox_Xcent->setValue(_Xcentre);
 205   SpinBox_Xcent->setSingleStep(_Xincr);
 206   // . Y du centre
 207   SpinBox_Ycent->setValue(_Ycentre);
 208   SpinBox_Ycent->setSingleStep(_Yincr);
 209   // . Z du centre
 210   SpinBox_Zcent->setValue(_Zcentre);
 211   SpinBox_Zcent->setSingleStep(_Zincr);
 212   // . X de l'axe
 213   SpinBox_Xaxis->setValue(0.);
 214   SpinBox_Xaxis->setSingleStep(0.1);
 215   // . Y de l'axe
 216   SpinBox_Yaxis->setValue(0.);
 217   SpinBox_Yaxis->setSingleStep(0.1);
 218   // . Z de l'axe
 219   SpinBox_Zaxis->setValue(1.);
 220   SpinBox_Zaxis->setSingleStep(0.1);
 221   // . Rayon
 222   SpinBox_Radius->setValue(_Rayon);
 223   SpinBox_Radius->setSingleStep(_Rayon/10.);
 224
 225   // Sphere
 226   // . X du centre
 227   SpinBox_Xcentre->setValue(_Xcentre);
 228   SpinBox_Xcentre->setSingleStep(_Xincr);
 229   // . Y du centre
 230   SpinBox_Ycentre->setValue(_Ycentre);
 231   SpinBox_Ycentre->setSingleStep(_Yincr);
 232   // . Z du centre
 233   SpinBox_Zcentre->setValue(_Zcentre);
 234   SpinBox_Zcentre->setSingleStep(_Zincr);
 235   // . Rayon
 236   SpinBox_Rayon->setValue(_Rayon);
 237   SpinBox_Rayon->setSingleStep(_Rayon/10.);
 238
 239   // Cone en rayons
 240   // . X des centres
 241   _BoundaryAnXcone1 = _Xcentre ;
 242   SpinBox_Cone_X1->setSingleStep(_Xincr);
 243   _BoundaryAnXcone2 = _Xcentre ;
 244   SpinBox_Cone_X2->setSingleStep(_Xincr);
 245   // . Y des centres
 246   _BoundaryAnYcone1 = _Ycentre ;
 247   SpinBox_Cone_Y1->setSingleStep(_Yincr);
 248   _BoundaryAnYcone2 = _Ycentre ;
 249   SpinBox_Cone_Y2->setSingleStep(_Yincr);
 250   // . Z des centres
 251   _BoundaryAnZcone1 = _Zmin ;
 252   SpinBox_Cone_Z1->setSingleStep(_Zincr);
 253   _BoundaryAnZcone2 = _Zmax ;
 254   SpinBox_Cone_Z2->setSingleStep(_Zincr);
 255   // . Rayons/Angles
 256   _BoundaryAnRayon1 = 0. ;
 257   _BoundaryAnRayon2 = _Rayon ;
 258   SpinBox_Cone_V2->setSingleStep(_Rayon/10.);
 259
 260   // Cone en angle
 261   convertRayonAngle(1) ;
 262   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 263   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 264   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 265   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 266   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 267   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 268   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 269
 270   // Tore
 271   // . X du centre
 272   SpinBoxToreXcent->setValue(_Xcentre);
 273   SpinBoxToreXcent->setSingleStep(_Xincr);
 274   // . Y du centre
 275   SpinBoxToreYcent->setValue(_Ycentre);
 276   SpinBoxToreYcent->setSingleStep(_Yincr);
 277   // . Z du centre
 278   SpinBoxToreZcent->setValue(_Zcentre);
 279   SpinBoxToreZcent->setSingleStep(_Zincr);
 280   // . X de l'axe
 281   SpinBoxToreXaxe->setValue(0.);
 282   SpinBoxToreXaxe->setSingleStep(0.1);
 283   // . Y de l'axe
 284   SpinBoxToreYaxe->setValue(0.);
 285   SpinBoxToreYaxe->setSingleStep(0.1);
 286   // . Z de l'axe
 287   SpinBoxToreZaxe->setValue(1.);
 288   SpinBoxToreZaxe->setSingleStep(0.1);
 289   // . Rayon de revolution
 290   SpinBoxToreRRev->setValue(_Rayon);
 291   SpinBoxToreRRev->setSingleStep(_Rayon/10.);
 292   // . Rayon primaire
 293   SpinBoxToreRPri->setValue(_Rayon/3.);
 294   SpinBoxToreRPri->setSingleStep(_Rayon/20.);
 295 }
 296 // ------------------------------------------------------------------------
 297 bool MonCreateBoundaryAn::PushOnApply()
 298 // ------------------------------------------------------------------------
 299 // Appele lorsque l'un des boutons Ok ou Apply est presse
 300 //
 301 {
 302   if (LEName->text().trimmed()=="")
 303   {
 304     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 305                               QObject::tr("HOM_BOUN_NAME") );
 306     return false;
 307   }
 308
 309   switch (_Type)
 310   {
 311       case 1 : // il s agit d un cylindre
 312       {
 313         if ((_BoundaryAnXcentre != SpinBox_Xcent->value())  ||
 314             (_BoundaryAnYcentre != SpinBox_Ycent->value())  ||
 315             (_BoundaryAnZcentre != SpinBox_Zcent->value())  ||
 316             (_BoundaryAnRayon   != SpinBox_Radius->value()) ||
 317             (_BoundaryAnXaxis   != SpinBox_Xaxis->value()) ||
 318             (_BoundaryAnYaxis   != SpinBox_Yaxis->value()) ||
 319             (_BoundaryAnZaxis   != SpinBox_Zaxis->value()) )
 320         {
 321           Chgt = true;
 322           _BoundaryAnXaxis= SpinBox_Xaxis->value();
 323           _BoundaryAnYaxis= SpinBox_Yaxis->value();
 324           _BoundaryAnZaxis= SpinBox_Zaxis->value();
 325           _BoundaryAnXcentre=SpinBox_Xcent->value();
 326           _BoundaryAnYcentre=SpinBox_Ycent->value();
 327           _BoundaryAnZcentre=SpinBox_Zcent->value();
 328           _BoundaryAnRayon=SpinBox_Radius->value();
 329         }
 330         break;
 331       }
 332
 333       case 2 : // il s agit d une sphere
 334       {
 335         if ((_BoundaryAnXcentre != SpinBox_Xcentre->value()) ||
 336             (_BoundaryAnYcentre != SpinBox_Ycentre->value()) ||
 337             (_BoundaryAnZcentre != SpinBox_Zcentre->value()) ||
 338             (_BoundaryAnRayon   != SpinBox_Rayon->value())  )
 339         {
 340            Chgt = true;
 341           _BoundaryAnXcentre=SpinBox_Xcentre->value();
 342           _BoundaryAnYcentre=SpinBox_Ycentre->value();
 343           _BoundaryAnZcentre=SpinBox_Zcentre->value();
 344           _BoundaryAnRayon=SpinBox_Rayon->value();
 345         }
 346         break;
 347       }
 348
 349       case 3 : // il s agit d un cone defini par un axe et un angle
 350       {
 351         if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 352             (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 353             (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 354             (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 355             (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 356             (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 357             (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 358         {
 359            Chgt = true;
 360           _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 361           _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 362           _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 363           _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 364           _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 365           _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 366           _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 367         }
 368         break;
 369       }
 370
 371       case 4 : // il s agit d un cone defini par les 2 rayons
 372       {
 373         if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 374             (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 375             (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 376             (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 377             (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 378             (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 379             (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 380             (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 381         {
 382            Chgt = true;
 383           _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 384           _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 385           _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 386           _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 387           _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 388           _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 389           _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 390           _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 391         }
 392         break;
 393       }
 394       case 5 : // il s agit d un tore
 395       {
 396         if ((_BoundaryAnToreXcentre != SpinBoxToreXcent->value())  ||
 397             (_BoundaryAnToreYcentre != SpinBoxToreYcent->value())  ||
 398             (_BoundaryAnToreZcentre != SpinBoxToreZcent->value())  ||
 399             (_BoundaryAnToreRRev   != SpinBoxToreRRev->value()) ||
 400             (_BoundaryAnToreRPri   != SpinBoxToreRPri->value()) ||
 401             (_BoundaryAnToreXaxe   != SpinBoxToreXaxe->value()) ||
 402             (_BoundaryAnToreYaxe   != SpinBoxToreYaxe->value()) ||
 403             (_BoundaryAnToreZaxe   != SpinBoxToreZaxe->value()) )
 404         {
 405           Chgt = true;
 406           _BoundaryAnToreXcentre= SpinBoxToreXcent->value();
 407           _BoundaryAnToreYcentre= SpinBoxToreYcent->value();
 408           _BoundaryAnToreZcentre= SpinBoxToreZcent->value();
 409           _BoundaryAnToreRRev=SpinBoxToreRRev->value();
 410           _BoundaryAnToreRPri=SpinBoxToreRPri->value();
 411           _BoundaryAnToreXaxe=SpinBoxToreXaxe->value();
 412           _BoundaryAnToreYaxe=SpinBoxToreYaxe->value();
 413           _BoundaryAnToreZaxe=SpinBoxToreZaxe->value();
 414         }
 415         break;
 416       }
 417
 418  }
 419
 420   bool bOK = CreateOrUpdateBoundaryAn();
 421
 422   if ( bOK ) { HOMARD_UTILS::updateObjBrowser() ; }
 423
 424   return bOK;
 425
 426 }
 427 // ---------------------------------------------------
 428 bool MonCreateBoundaryAn:: CreateOrUpdateBoundaryAn()
 429 //----------------------------------------------------
 430 //  Creation de l'objet boundary
 431 {
 432   _aName = LEName->text().trimmed();
 433   switch (_Type)
 434   {
 435     case 1 : // il s agit d un cylindre
 436     {
 437       try
 438       {
 439         aBoundaryAn = myHomardGen->CreateBoundaryCylinder(CORBA::string_dup(_aName.toStdString().c_str()), \
 440         _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnXaxis, _BoundaryAnYaxis, _BoundaryAnZaxis, _BoundaryAnRayon );
 441       }
 442       catch( SALOME::SALOME_Exception& S_ex )
 443       {
 444         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 445                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 446         return false ;
 447       }
 448       break;
 449     }
 450     case 2 : // il s agit d une sphere
 451     {
 452       try
 453       {
 454         aBoundaryAn = myHomardGen->CreateBoundarySphere(CORBA::string_dup(_aName.toStdString().c_str()), \
 455         _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnRayon);
 456       }
 457       catch( SALOME::SALOME_Exception& S_ex )
 458       {
 459         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 460                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 461         return false ;
 462       }
 463       break;
 464     }
 465     case 3 : // il s agit d un cone defini par un axe et un angle
 466     {
 467       try
 468       {
 469         aBoundaryAn = myHomardGen->CreateBoundaryConeA(CORBA::string_dup(_aName.toStdString().c_str()), \
 470         _BoundaryAnXaxisCone, _BoundaryAnYaxisCone, _BoundaryAnZaxisCone, _BoundaryAngle, \
 471         _BoundaryAnXorigCone, _BoundaryAnYorigCone, _BoundaryAnYorigCone);
 472       }
 473       catch( SALOME::SALOME_Exception& S_ex )
 474       {
 475         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 476                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 477         return false ;
 478       }
 479       break;
 480     }
 481     case 4 : // il s agit d un cone defini par les 2 rayons
 482     {
 483       try
 484       {
 485         aBoundaryAn = myHomardGen->CreateBoundaryConeR(CORBA::string_dup(_aName.toStdString().c_str()), \
 486         _BoundaryAnXcone1, _BoundaryAnYcone1, _BoundaryAnZcone1, _BoundaryAnRayon1, \
 487         _BoundaryAnXcone2, _BoundaryAnYcone2, _BoundaryAnZcone2, _BoundaryAnRayon2);
 488       }
 489       catch( SALOME::SALOME_Exception& S_ex )
 490       {
 491         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 492                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 493         return false ;
 494       }
 495       break;
 496     }
 497    case 5 : // il s agit d un tore
 498     {
 499       try
 500       {
 501         aBoundaryAn = myHomardGen->CreateBoundaryTorus(CORBA::string_dup(_aName.toStdString().c_str()), \
 502         _BoundaryAnToreXcentre, _BoundaryAnToreYcentre, _BoundaryAnToreZcentre, _BoundaryAnToreXaxe, _BoundaryAnToreYaxe, _BoundaryAnToreZaxe, _BoundaryAnToreRRev, _BoundaryAnToreRPri );
 503       }
 504       catch( SALOME::SALOME_Exception& S_ex )
 505       {
 506         QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 507                                   QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 508         return false ;
 509      }
 510       break;
 511     }
 512   }
 513   _parent->AddBoundaryAn(_aName);
 514
 515   return true;
 516 }
 517 // ------------------------------------------------------------------------
 518 void MonCreateBoundaryAn::PushOnOK()
 519 // ------------------------------------------------------------------------
 520 {
 521      if (PushOnApply()) this->close();
 522 }
 523 // ------------------------------------------------------------------------
 524 void MonCreateBoundaryAn::PushOnHelp()
 525 // ------------------------------------------------------------------------
 526 {
 527   std::string LanguageShort = myHomardGen->GetLanguageShort();
 528   HOMARD_UTILS::PushOnHelp(QString("gui_create_boundary.html"), QString("un-cylindre"), QString(LanguageShort.c_str()));
 529 }
 530
 531 // -----------------------------------
 532 void MonCreateBoundaryAn::SetNewName()
 533 // -----------------------------------
 534 {
 535 // Recherche d'un nom par defaut qui n'existe pas encore
 536
 537   HOMARD::listeBoundarys_var MyObjects = myHomardGen->GetAllBoundarysName();
 538   int num = 0; QString aName="";
 539   while (aName=="" )
 540   {
 541     aName.setNum(num+1) ;
 542     aName.insert(0, QString("Boun_")) ;
 543     for ( int i=0; i<MyObjects->length(); i++)
 544     {
 545       if ( aName ==  QString(MyObjects[i]))
 546       {
 547         num ++ ;
 548         aName = "" ;
 549         break ;
 550       }
 551    }
 552   }
 553   LEName->setText(aName);
 554 }
 555 // ------------------------------------------------------------------------
 556 void MonCreateBoundaryAn::SetCylinder()
 557 // ------------------------------------------------------------------------
 558 {
 559   MESSAGE("Debut de SetCylinder")
 560   gBCylindre->setVisible(1);
 561   gBSphere->setVisible(0);
 562   gBCone->setVisible(0);
 563   gBTore->setVisible(0);
 564 //
 565   _Type=1;
 566 //
 567   adjustSize();
 568 //   MESSAGE("Fin de SetCylinder")
 569 }
 570 // ------------------------------------------------------------------------
 571 void MonCreateBoundaryAn::SetSphere()
 572 // ------------------------------------------------------------------------
 573 {
 574   MESSAGE("Debut de SetSphere")
 575   gBCylindre->setVisible(0);
 576   gBSphere->setVisible(1);
 577   gBCone->setVisible(0);
 578   gBTore->setVisible(0);
 579 //
 580   _Type=2;
 581 //
 582   adjustSize();
 583 //   MESSAGE("Fin de SetSphere")
 584 }
 585 // ------------------------------------------------------------------------
 586 void MonCreateBoundaryAn::SetConeR()
 587 // ------------------------------------------------------------------------
 588 {
 589   MESSAGE("Debut de SetConeR")
 590 //
 591 // Stockage et conversion des valeurs si elles ont change
 592   if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 593       (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 594       (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 595       (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 596       (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 597       (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 598       (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 599   {
 600     MESSAGE("Stockage et conversion")
 601     _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 602     _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 603     _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 604     _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 605     _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 606     _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 607     _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 608     convertRayonAngle(-1) ;
 609   }
 610 //
 611   _Type=4;
 612 //
 613   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X centre 1", 0));
 614   SpinBox_Cone_X1->setValue(_BoundaryAnXcone1);
 615   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y centre 1", 0));
 616   SpinBox_Cone_Y1->setValue(_BoundaryAnYcone1);
 617   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z centre 1", 0));
 618   SpinBox_Cone_Z1->setValue(_BoundaryAnZcone1);
 619 //
 620   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Radius 1", 0));
 621   SpinBox_Cone_V1->setSingleStep(_Rayon/10.);
 622   SpinBox_Cone_V1->setMaximum(100000.*_DMax);
 623   SpinBox_Cone_V1->setValue(_BoundaryAnRayon1);
 624 //
 625   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre 2", 0));
 626   SpinBox_Cone_X2->setValue(_BoundaryAnXcone2);
 627   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre 2", 0));
 628   SpinBox_Cone_Y2->setValue(_BoundaryAnYcone2);
 629   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre 2", 0));
 630   SpinBox_Cone_Z2->setValue(_BoundaryAnZcone2);
 631 //
 632   TLCone_V2->setVisible(1);
 633   SpinBox_Cone_V2->setVisible(1);
 634   TLCone_V2->setText(QApplication::translate("CreateBoundaryAn", "Radius 2", 0));
 635   SpinBox_Cone_V2->setValue(_BoundaryAnRayon2);
 636 //
 637 //   MESSAGE("Fin de SetConeR")
 638 }
 639 // ------------------------------------------------------------------------
 640 void MonCreateBoundaryAn::SetConeA()
 641 // ------------------------------------------------------------------------
 642 {
 643   MESSAGE("Debut de SetConeA")
 644 // Stockage et conversion des valeurs si elles ont change
 645   if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 646       (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 647       (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 648       (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 649       (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 650       (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 651       (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 652       (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 653   {
 654     MESSAGE("Stockage et conversion")
 655     _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 656     _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 657     _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 658     _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 659     _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 660     _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 661     _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 662     _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 663     convertRayonAngle(1) ;
 664   }
 665 //
 666   _Type=3;
 667 //
 668   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X axis", 0));
 669   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 670   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y axis", 0));
 671   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 672   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z axis", 0));
 673   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 674 //
 675   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre", 0));
 676   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 677   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre", 0));
 678   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 679   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre", 0));
 680   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 681 //
 682   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Angle", 0));
 683   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 684   SpinBox_Cone_V1->setSingleStep(1.);
 685   SpinBox_Cone_V1->setMaximum(90.);
 686 //
 687   TLCone_V2->setVisible(0);
 688   SpinBox_Cone_V2->setVisible(0);
 689 //   MESSAGE("Fin de SetConeA")
 690 }
 691
 692
 693 // ------------------------------------------------------------------------
 694 void MonCreateBoundaryAn::SetCone()
 695 // ------------------------------------------------------------------------
 696 {
 697   MESSAGE("Debut de SetCone")
 698   gBCylindre->setVisible(0);
 699   gBSphere->setVisible(0);
 700   gBCone->setVisible(1);
 701   gBTore->setVisible(0);
 702 //
 703   if ( RB_Def_radius->isChecked() )
 704   {
 705     SetConeR();
 706   }
 707   else
 708   {
 709     SetConeA();
 710   }
 711 //
 712   adjustSize();
 713 //   MESSAGE("Fin de SetCone")
 714 }
 715 // ------------------------------------------------------------------------
 716 void MonCreateBoundaryAn::SetTore()
 717 // ------------------------------------------------------------------------
 718 {
 719   MESSAGE("Debut de SetTore")
 720   gBCylindre->setVisible(0);
 721   gBSphere->setVisible(0);
 722   gBCone->setVisible(0);
 723   gBTore->setVisible(1);
 724 //
 725   _Type=5;
 726 //
 727   adjustSize();
 728 //   MESSAGE("Fin de SetTore")
 729 }
 730 // ------------------------------------------------------------------------
 731 void MonCreateBoundaryAn::convertRayonAngle(int option)
 732 // ------------------------------------------------------------------------
 733 // Conversion entre les deux formulations du cone :
 734 // par deux rayons ou avec un axe et un angle.
 735 // Voir sfcoi1 de HOMARD
 736 {
 737   MESSAGE("Debut de convertRayonAngle, option = "<<option)
 738 //
 739 //         o
 740 //         !    .
 741 //         !        .
 742 //       RA!            .
 743 //         !                o
 744 //         !              RB!   .
 745 //         !                !       .
 746 //         A----------------B----------O
 747 //
 748 //   Thales : RA/RB = AO/BO  ==> BO = AB*RB/(RA-RB)
 749 //   Angle  : tg(alpha) = RA/AO
 750 //
 751   double daux ;
 752 // De rayon vers angle :
 753   if ( option == 1 )
 754   {
 755     double xa, ya, za, ra ;
 756     double xb, yb, zb, rb ;
 757 // Positionnement de A vers B, avec RA>RB
 758     if ( _BoundaryAnRayon1 > _BoundaryAnRayon2 )
 759     {
 760       xa = _BoundaryAnXcone1 ;
 761       ya = _BoundaryAnYcone1 ;
 762       za = _BoundaryAnZcone1 ;
 763       ra = _BoundaryAnRayon1 ;
 764       xb = _BoundaryAnXcone2 ;
 765       yb = _BoundaryAnYcone2 ;
 766       zb = _BoundaryAnZcone2 ;
 767       rb = _BoundaryAnRayon2 ;
 768     }
 769     else
 770     {
 771       xa = _BoundaryAnXcone2 ;
 772       ya = _BoundaryAnYcone2 ;
 773       za = _BoundaryAnZcone2 ;
 774       ra = _BoundaryAnRayon2 ;
 775       xb = _BoundaryAnXcone1 ;
 776       yb = _BoundaryAnYcone1 ;
 777       zb = _BoundaryAnZcone1 ;
 778       rb = _BoundaryAnRayon1 ;
 779     }
 780 // Axe : relie les deux centres, de A vers B.  L'axe est normalise
 781     _BoundaryAnXaxisCone = xb - xa ;
 782     _BoundaryAnYaxisCone = yb - ya ;
 783     _BoundaryAnZaxisCone = zb - za ;
 784     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 785     _BoundaryAnXaxisCone = _BoundaryAnXaxisCone/daux ;
 786     _BoundaryAnYaxisCone = _BoundaryAnYaxisCone/daux ;
 787     _BoundaryAnZaxisCone = _BoundaryAnZaxisCone/daux ;
 788 // Origine
 789     daux = daux * rb / (ra-rb) ;
 790     _BoundaryAnXorigCone = xb + daux*_BoundaryAnXaxisCone ;
 791     _BoundaryAnYorigCone = yb + daux*_BoundaryAnYaxisCone ;
 792     _BoundaryAnZorigCone = zb + daux*_BoundaryAnZaxisCone ;
 793 // Angle en degre
 794     daux = ra / sqrt((_BoundaryAnXorigCone-xa)*(_BoundaryAnXorigCone-xa) + (_BoundaryAnYorigCone-ya)*(_BoundaryAnYorigCone-ya) + (_BoundaryAnZorigCone-za)*(_BoundaryAnZorigCone-za) ) ;
 795     _BoundaryAngle = atan(daux)*180./PI ;
 796   }
 797 // D'angle vers rayon :
 798   else
 799   {
 800     double xax, yax, zax ;
 801 // L'axe est normalise
 802     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 803     xax = _BoundaryAnXaxisCone/daux ;
 804     yax = _BoundaryAnYaxisCone/daux ;
 805     zax = _BoundaryAnZaxisCone/daux ;
 806 // Centre 1 : l'origine
 807     _BoundaryAnXcone1 = _BoundaryAnXorigCone ;
 808     _BoundaryAnYcone1 = _BoundaryAnYorigCone ;
 809     _BoundaryAnZcone1 = _BoundaryAnZorigCone ;
 810 // Rayon 1 : nul
 811     _BoundaryAnRayon1 = 0. ;
 812 // Centre 2 : l'origine decalee d'une longueur arbitraire le long de l'axe
 813     _BoundaryAnXcone2 = _BoundaryAnXorigCone + _DMax*xax ;
 814     _BoundaryAnYcone2 = _BoundaryAnYorigCone + _DMax*yax ;
 815     _BoundaryAnZcone2 = _BoundaryAnZorigCone + _DMax*zax ;
 816 // Rayon 2 : a calculer
 817     _BoundaryAnRayon2 = _DMax*tan(_BoundaryAngle*PI/180.) ;
 818   }
 819 //   MESSAGE("Fin de convertRayonAngle")
 820 }
 821
 822