src/SMESHGUI/SMESHGUI_HomardBoundaryDlg.cxx

   1 // Copyright (C) 2011-2022  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 "SMESHGUI_HomardBoundaryDlg.h"
  21
  22 #include "SMESHGUI_HomardAdaptDlg.h"
  23 #include "SMESHGUI_HomardListGroup.h"
  24
  25 #include "SMESHGUI_Utils.h"
  26
  27 #include <QFileDialog>
  28 #include <QMessageBox>
  29
  30 #include "SalomeApp_Tools.h"
  31 #include "SMESHGUI_HomardUtils.h"
  32 #include <utilities.h>
  33
  34 #include <SUIT_Desktop.h>
  35 #include <SUIT_MessageBox.h>
  36 #include <SUIT_ResourceMgr.h>
  37 #include <SUIT_Session.h>
  38 #include <SUIT_ViewManager.h>
  39
  40 #include "math.h"
  41 #define PI 3.141592653589793
  42
  43 using namespace std;
  44
  45 // ----------------------------------------------------------------------------------
  46 SMESH_CreateBoundaryAn::SMESH_CreateBoundaryAn(SMESHGUI_HomardAdaptDlg* parent, bool modal,
  47                                                SMESHHOMARD::HOMARD_Gen_var myHomardGen0,
  48                                                QString caseName) :
  49 /* Constructs a SMESH_CreateBoundaryAn
  50    appele pour une vraie creation
  51    initialise un cylindre et non une sphere
  52 */
  53     QDialog(0), SMESH_Ui_CreateBoundaryAn(),
  54     _parent(parent),
  55     _Name (""),
  56     _Type(1),
  57     _BoundaryAnXcentre(0), _BoundaryAnYcentre(0), _BoundaryAnZcentre(0), _BoundaryAnRayon(0),
  58     _BoundaryAnXaxis(0), _BoundaryAnYaxis(0), _BoundaryAnZaxis(0),
  59     _Xcentre(0), _Ycentre(0), _Zcentre(0), _Rayon(0),
  60     _Xmin(0), _Xmax(0), _Xincr(0), _Ymin(0), _Ymax(0), _Yincr(0), _Zmin(0), _Zmax(0), _Zincr(0), _DMax(0),
  61     _BoundaryAnXcone1(0), _BoundaryAnYcone1(0), _BoundaryAnZcone1(0), _BoundaryAnRayon1(0),
  62     _BoundaryAnXcone2(0), _BoundaryAnYcone2(0), _BoundaryAnZcone2(0), _BoundaryAnRayon2(0),
  63     _BoundaryAnXaxisCone(0), _BoundaryAnYaxisCone(0), _BoundaryAnZaxisCone(0),
  64     _BoundaryAnXorigCone(0), _BoundaryAnYorigCone(0), _BoundaryAnZorigCone(0),
  65     _BoundaryAngle(0),
  66     _BoundaryAnToreXcentre(0), _BoundaryAnToreYcentre(0), _BoundaryAnToreZcentre(0),
  67     _BoundaryAnToreXaxe(0), _BoundaryAnToreYaxe(0), _BoundaryAnToreZaxe(0),
  68     _BoundaryAnToreRRev(0), _BoundaryAnToreRPri(0),
  69     Chgt (false)
  70     {
  71       MESSAGE("Constructeur") ;
  72       myHomardGen = SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen0);
  73       setupUi(this);
  74       setModal(modal);
  75
  76       // Gestion des icones
  77       QPixmap pix ;
  78       QIcon IS ;
  79       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  80       pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
  81       IS=QIcon(pix);
  82       RBSphere->setIcon(IS);
  83       pix = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
  84       IS=QIcon(pix);
  85       RBCylindre->setIcon(IS);
  86       pix = resMgr->loadPixmap( "HOMARD", "cone.png" );
  87       IS=QIcon(pix);
  88       RBCone->setIcon(IS);
  89       pix = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
  90       IS=QIcon(pix);
  91       RB_Def_angle->setIcon(IS);
  92       pix = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
  93       IS=QIcon(pix);
  94       RB_Def_radius->setIcon(IS);
  95       pix = resMgr->loadPixmap( "HOMARD", "toruspointvector.png" );
  96       IS=QIcon(pix);
  97       RBTore->setIcon(IS);
  98
  99       InitConnect( );
 100
 101       SetNewName() ;
 102       InitValBoundaryAn();          // Cherche les valeurs de la boite englobante le maillage
 103       InitMinMax();                 // Initialise les bornes des boutons
 104       SetCylinder();                // Propose un cylindre en premier choix
 105     }
 106
 107 // -------------------------------------------------------------------------------
 108 SMESH_CreateBoundaryAn::SMESH_CreateBoundaryAn(SMESHGUI_HomardAdaptDlg* parent,
 109                                                SMESHHOMARD::HOMARD_Gen_var myHomardGen0,
 110                                                QString caseName):
 111     QDialog(0), SMESH_Ui_CreateBoundaryAn(),
 112     _parent(parent),
 113     _Name (""),
 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  SMESH_CreateBoundaryAn")
 123       myHomardGen = SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen0);
 124       setupUi(this);
 125       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 126       QPixmap pix = resMgr->loadPixmap( "HOMARD", "spherepoint.png" );
 127       QIcon IS=QIcon(pix);
 128       RBSphere->setIcon(IS);
 129       QPixmap pix2 = resMgr->loadPixmap( "HOMARD", "cylinderpointvector.png" );
 130       QIcon IS2=QIcon(pix2);
 131       RBCylindre->setIcon(IS2);
 132       QPixmap pix3 = resMgr->loadPixmap( "HOMARD", "cone.png" );
 133       QIcon IS3=QIcon(pix3);
 134       RBCone->setIcon(IS3);
 135       QPixmap pix4 = resMgr->loadPixmap( "HOMARD", "conepointvector.png" );
 136       QIcon IS4=QIcon(pix4);
 137       RB_Def_angle->setIcon(IS4);
 138       QPixmap pix5 = resMgr->loadPixmap( "HOMARD", "conedxyz.png" );
 139       QIcon IS5=QIcon(pix5);
 140       RB_Def_radius->setIcon(IS5);
 141       setModal(true);
 142       InitConnect();
 143     }
 144
 145 // ------------------------------------------------------------------------
 146 SMESH_CreateBoundaryAn::~SMESH_CreateBoundaryAn()
 147 // ------------------------------------------------------------------------
 148 {
 149     // no need to delete child widgets, Qt does it all for us
 150 }
 151 // ------------------------------------------------------------------------
 152 void SMESH_CreateBoundaryAn::InitConnect()
 153 // ------------------------------------------------------------------------
 154 {
 155     connect( RBCylindre,    SIGNAL(clicked()) , this, SLOT(SetCylinder()) ) ;
 156     connect( RBSphere,      SIGNAL(clicked()) , this, SLOT(SetSphere()) ) ;
 157     connect( RBCone,        SIGNAL(clicked()) , this, SLOT(SetCone()) ) ;
 158     connect( RB_Def_radius, SIGNAL(clicked()) , this, SLOT(SetConeR()) );
 159     connect( RB_Def_angle,  SIGNAL(clicked()) , this, SLOT(SetConeA()) );
 160     connect( RBTore,        SIGNAL(clicked()) , this, SLOT(SetTore()) ) ;
 161     connect( buttonOk,     SIGNAL( pressed() ), this, SLOT( PushOnOK() ) );
 162     connect( buttonApply,  SIGNAL( pressed() ), this, SLOT( PushOnApply() ) );
 163     connect( buttonCancel, SIGNAL( pressed() ), this, SLOT( close() ) );
 164     connect( buttonHelp,   SIGNAL( pressed() ), this, SLOT( PushOnHelp() ) );
 165 }
 166 // ------------------------------------------------------------------------
 167 void SMESH_CreateBoundaryAn::InitValBoundaryAn()
 168 // ------------------------------------------------------------------------
 169 {
 170   //
 171   //  1. Les coordonnees extremes du maillage
 172   //
 173     SMESHHOMARD::HOMARD_Cas_var aCas = myHomardGen->GetCase();
 174     SMESHHOMARD::extrema_var  MesExtremes = aCas->GetBoundingBox();
 175     int num = MesExtremes->length() ;
 176     ASSERT(num == 10);
 177     _Xmin=MesExtremes[0]; _Xmax=MesExtremes[1]; _Xincr=MesExtremes[2];
 178     _Ymin=MesExtremes[3]; _Ymax=MesExtremes[4]; _Yincr=MesExtremes[5];
 179     _Zmin=MesExtremes[6]; _Zmax=MesExtremes[7]; _Zincr=MesExtremes[8];
 180     _DMax=MesExtremes[9];
 181      MESSAGE ("_Xmin : " << _Xmin << " _Xmax : " << _Xmax << " _Xincr : " << _Xincr ) ;
 182      MESSAGE ("_Ymin : " << _Ymin << " _Ymax : " << _Ymax << " _Yincr : " << _Yincr ) ;
 183      MESSAGE ("_Zmin : " << _Zmin << " _Zmax : " << _Zmax << " _Zincr : " << _Zincr) ;
 184      MESSAGE ("_DMax : " << _DMax);
 185
 186 //  2. Caracteristiques des frontieres
 187 // en X
 188     _Xcentre=(_Xmin + _Xmax)/2.;
 189 // en Y
 190     _Ycentre=(_Ymin + _Ymax)/2.;
 191 // en Z
 192     _Zcentre=(_Zmin + _Zmax)/2.;
 193 // Rayon
 194     _Rayon= _DMax/4.;
 195 }
 196
 197 // ------------------------------------------------------------------------
 198 void SMESH_CreateBoundaryAn::InitMinMax()
 199 // ------------------------------------------------------------------------
 200 {
 201   // Cylindre
 202   // . X du centre
 203   SpinBox_Xcent->setValue(_Xcentre);
 204   SpinBox_Xcent->setSingleStep(_Xincr);
 205   // . Y du centre
 206   SpinBox_Ycent->setValue(_Ycentre);
 207   SpinBox_Ycent->setSingleStep(_Yincr);
 208   // . Z du centre
 209   SpinBox_Zcent->setValue(_Zcentre);
 210   SpinBox_Zcent->setSingleStep(_Zincr);
 211   // . X de l'axe
 212   SpinBox_Xaxis->setValue(0.);
 213   SpinBox_Xaxis->setSingleStep(0.1);
 214   // . Y de l'axe
 215   SpinBox_Yaxis->setValue(0.);
 216   SpinBox_Yaxis->setSingleStep(0.1);
 217   // . Z de l'axe
 218   SpinBox_Zaxis->setValue(1.);
 219   SpinBox_Zaxis->setSingleStep(0.1);
 220   // . Rayon
 221   SpinBox_Radius->setValue(_Rayon);
 222   SpinBox_Radius->setSingleStep(_Rayon/10.);
 223
 224   // Sphere
 225   // . X du centre
 226   SpinBox_Xcentre->setValue(_Xcentre);
 227   SpinBox_Xcentre->setSingleStep(_Xincr);
 228   // . Y du centre
 229   SpinBox_Ycentre->setValue(_Ycentre);
 230   SpinBox_Ycentre->setSingleStep(_Yincr);
 231   // . Z du centre
 232   SpinBox_Zcentre->setValue(_Zcentre);
 233   SpinBox_Zcentre->setSingleStep(_Zincr);
 234   // . Rayon
 235   SpinBox_Rayon->setValue(_Rayon);
 236   SpinBox_Rayon->setSingleStep(_Rayon/10.);
 237
 238   // Cone en rayons
 239   // . X des centres
 240   _BoundaryAnXcone1 = _Xcentre ;
 241   SpinBox_Cone_X1->setSingleStep(_Xincr);
 242   _BoundaryAnXcone2 = _Xcentre ;
 243   SpinBox_Cone_X2->setSingleStep(_Xincr);
 244   // . Y des centres
 245   _BoundaryAnYcone1 = _Ycentre ;
 246   SpinBox_Cone_Y1->setSingleStep(_Yincr);
 247   _BoundaryAnYcone2 = _Ycentre ;
 248   SpinBox_Cone_Y2->setSingleStep(_Yincr);
 249   // . Z des centres
 250   _BoundaryAnZcone1 = _Zmin ;
 251   SpinBox_Cone_Z1->setSingleStep(_Zincr);
 252   _BoundaryAnZcone2 = _Zmax ;
 253   SpinBox_Cone_Z2->setSingleStep(_Zincr);
 254   // . Rayons/Angles
 255   _BoundaryAnRayon1 = 0. ;
 256   _BoundaryAnRayon2 = _Rayon ;
 257   SpinBox_Cone_V2->setSingleStep(_Rayon/10.);
 258
 259   // Cone en angle
 260   convertRayonAngle(1) ;
 261   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 262   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 263   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 264   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 265   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 266   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 267   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 268
 269   // Tore
 270   // . X du centre
 271   SpinBoxToreXcent->setValue(_Xcentre);
 272   SpinBoxToreXcent->setSingleStep(_Xincr);
 273   // . Y du centre
 274   SpinBoxToreYcent->setValue(_Ycentre);
 275   SpinBoxToreYcent->setSingleStep(_Yincr);
 276   // . Z du centre
 277   SpinBoxToreZcent->setValue(_Zcentre);
 278   SpinBoxToreZcent->setSingleStep(_Zincr);
 279   // . X de l'axe
 280   SpinBoxToreXaxe->setValue(0.);
 281   SpinBoxToreXaxe->setSingleStep(0.1);
 282   // . Y de l'axe
 283   SpinBoxToreYaxe->setValue(0.);
 284   SpinBoxToreYaxe->setSingleStep(0.1);
 285   // . Z de l'axe
 286   SpinBoxToreZaxe->setValue(1.);
 287   SpinBoxToreZaxe->setSingleStep(0.1);
 288   // . Rayon de revolution
 289   SpinBoxToreRRev->setValue(_Rayon);
 290   SpinBoxToreRRev->setSingleStep(_Rayon/10.);
 291   // . Rayon primaire
 292   SpinBoxToreRPri->setValue(_Rayon/3.);
 293   SpinBoxToreRPri->setSingleStep(_Rayon/20.);
 294 }
 295 // ------------------------------------------------------------------------
 296 bool SMESH_CreateBoundaryAn::PushOnApply()
 297 // ------------------------------------------------------------------------
 298 // Appele lorsque l'un des boutons Ok ou Apply est presse
 299 //
 300 {
 301   if (LEName->text().trimmed()=="")
 302   {
 303     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 304                               QObject::tr("HOM_BOUN_NAME") );
 305     return false;
 306   }
 307
 308   switch (_Type)
 309   {
 310       case 1 : // il s agit d un cylindre
 311       {
 312         if ((_BoundaryAnXcentre != SpinBox_Xcent->value())  ||
 313             (_BoundaryAnYcentre != SpinBox_Ycent->value())  ||
 314             (_BoundaryAnZcentre != SpinBox_Zcent->value())  ||
 315             (_BoundaryAnRayon   != SpinBox_Radius->value()) ||
 316             (_BoundaryAnXaxis   != SpinBox_Xaxis->value()) ||
 317             (_BoundaryAnYaxis   != SpinBox_Yaxis->value()) ||
 318             (_BoundaryAnZaxis   != SpinBox_Zaxis->value()) )
 319         {
 320           Chgt = true;
 321           _BoundaryAnXaxis= SpinBox_Xaxis->value();
 322           _BoundaryAnYaxis= SpinBox_Yaxis->value();
 323           _BoundaryAnZaxis= SpinBox_Zaxis->value();
 324           _BoundaryAnXcentre=SpinBox_Xcent->value();
 325           _BoundaryAnYcentre=SpinBox_Ycent->value();
 326           _BoundaryAnZcentre=SpinBox_Zcent->value();
 327           _BoundaryAnRayon=SpinBox_Radius->value();
 328         }
 329         break;
 330       }
 331
 332       case 2 : // il s agit d une sphere
 333       {
 334         if ((_BoundaryAnXcentre != SpinBox_Xcentre->value()) ||
 335             (_BoundaryAnYcentre != SpinBox_Ycentre->value()) ||
 336             (_BoundaryAnZcentre != SpinBox_Zcentre->value()) ||
 337             (_BoundaryAnRayon   != SpinBox_Rayon->value())  )
 338         {
 339            Chgt = true;
 340           _BoundaryAnXcentre=SpinBox_Xcentre->value();
 341           _BoundaryAnYcentre=SpinBox_Ycentre->value();
 342           _BoundaryAnZcentre=SpinBox_Zcentre->value();
 343           _BoundaryAnRayon=SpinBox_Rayon->value();
 344         }
 345         break;
 346       }
 347
 348       case 3 : // il s agit d un cone defini par un axe et un angle
 349       {
 350         if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 351             (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 352             (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 353             (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 354             (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 355             (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 356             (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 357         {
 358            Chgt = true;
 359           _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 360           _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 361           _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 362           _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 363           _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 364           _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 365           _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 366         }
 367         break;
 368       }
 369
 370       case 4 : // il s agit d un cone defini par les 2 rayons
 371       {
 372         if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 373             (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 374             (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 375             (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 376             (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 377             (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 378             (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 379             (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 380         {
 381            Chgt = true;
 382           _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 383           _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 384           _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 385           _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 386           _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 387           _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 388           _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 389           _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 390         }
 391         break;
 392       }
 393       case 5 : // il s agit d un tore
 394       {
 395         if ((_BoundaryAnToreXcentre != SpinBoxToreXcent->value())  ||
 396             (_BoundaryAnToreYcentre != SpinBoxToreYcent->value())  ||
 397             (_BoundaryAnToreZcentre != SpinBoxToreZcent->value())  ||
 398             (_BoundaryAnToreRRev   != SpinBoxToreRRev->value()) ||
 399             (_BoundaryAnToreRPri   != SpinBoxToreRPri->value()) ||
 400             (_BoundaryAnToreXaxe   != SpinBoxToreXaxe->value()) ||
 401             (_BoundaryAnToreYaxe   != SpinBoxToreYaxe->value()) ||
 402             (_BoundaryAnToreZaxe   != SpinBoxToreZaxe->value()) )
 403         {
 404           Chgt = true;
 405           _BoundaryAnToreXcentre= SpinBoxToreXcent->value();
 406           _BoundaryAnToreYcentre= SpinBoxToreYcent->value();
 407           _BoundaryAnToreZcentre= SpinBoxToreZcent->value();
 408           _BoundaryAnToreRRev=SpinBoxToreRRev->value();
 409           _BoundaryAnToreRPri=SpinBoxToreRPri->value();
 410           _BoundaryAnToreXaxe=SpinBoxToreXaxe->value();
 411           _BoundaryAnToreYaxe=SpinBoxToreYaxe->value();
 412           _BoundaryAnToreZaxe=SpinBoxToreZaxe->value();
 413         }
 414         break;
 415       }
 416
 417  }
 418
 419 // Controles
 420 // L'axe pour un cylindre
 421   if ( _Type == 5 )
 422   {
 423     double daux = _BoundaryAnXaxis*_BoundaryAnXaxis + _BoundaryAnYaxis*_BoundaryAnYaxis + _BoundaryAnZaxis*_BoundaryAnZaxis ;
 424     if ( daux < 0.0000001 )
 425     {
 426       QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 427                                 QObject::tr("HOM_AXE") );
 428       return false;
 429     }
 430   }
 431
 432   //
 433   // Création ou mise à jour de la frontière
 434   //
 435   bool bOK = CreateOrUpdateBoundaryAn();
 436
 437   //if ( bOK ) { HOMARD_UTILS::updateObjBrowser() ; }
 438
 439   return bOK;
 440
 441 }
 442 // ---------------------------------------------------
 443 bool SMESH_CreateBoundaryAn::CreateOrUpdateBoundaryAn()
 444 //----------------------------------------------------
 445 //  Creation de l'objet boundary
 446 {
 447   MESSAGE("Debut de CreateOrUpdateBoundaryAn avec _Type ="<<_Type<<", _Name ="<<_Name.toStdString().c_str()<<" et LEName ="<<LEName->text().trimmed().toStdString().c_str());
 448 //
 449   if (_Name != LEName->text().trimmed())
 450   {
 451     _Name = LEName->text().trimmed() ;
 452     try
 453     {
 454       switch (_Type)
 455       {
 456         case 1 : // il s agit d un cylindre
 457         { aBoundaryAn = myHomardGen->CreateBoundaryCylinder(CORBA::string_dup(_Name.toStdString().c_str()), \
 458             _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnXaxis, _BoundaryAnYaxis, _BoundaryAnZaxis, _BoundaryAnRayon );
 459           break;
 460         }
 461         case 2 : // il s agit d une sphere
 462         { aBoundaryAn = myHomardGen->CreateBoundarySphere(CORBA::string_dup(_Name.toStdString().c_str()), \
 463             _BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnRayon);
 464           break;
 465        }
 466         case 3 : // il s agit d un cone defini par un axe et un angle
 467         { aBoundaryAn = myHomardGen->CreateBoundaryConeA(CORBA::string_dup(_Name.toStdString().c_str()), \
 468             _BoundaryAnXaxisCone, _BoundaryAnYaxisCone, _BoundaryAnZaxisCone, _BoundaryAngle, \
 469             _BoundaryAnXorigCone, _BoundaryAnYorigCone, _BoundaryAnYorigCone);
 470           break;
 471         }
 472         case 4 : // il s agit d un cone defini par les 2 rayons
 473         { aBoundaryAn = myHomardGen->CreateBoundaryConeR(CORBA::string_dup(_Name.toStdString().c_str()), \
 474             _BoundaryAnXcone1, _BoundaryAnYcone1, _BoundaryAnZcone1, _BoundaryAnRayon1, \
 475             _BoundaryAnXcone2, _BoundaryAnYcone2, _BoundaryAnZcone2, _BoundaryAnRayon2);
 476           break;
 477         }
 478         case 5 : // il s agit d un tore
 479         { aBoundaryAn = myHomardGen->CreateBoundaryTorus(CORBA::string_dup(_Name.toStdString().c_str()), \
 480             _BoundaryAnToreXcentre, _BoundaryAnToreYcentre, _BoundaryAnToreZcentre, _BoundaryAnToreXaxe, _BoundaryAnToreYaxe, _BoundaryAnToreZaxe, _BoundaryAnToreRRev, _BoundaryAnToreRPri );
 481           break;
 482         }
 483       }
 484     }
 485     catch( SALOME::SALOME_Exception& S_ex )
 486     {
 487       QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 488                                 QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 489       return false ;
 490     }
 491     _parent->AddBoundaryAn(_Name);
 492
 493     return true;
 494   }
 495   else {
 496     QMessageBox::warning( 0, QObject::tr("HOM_WARNING"),
 497                              QObject::tr("HOM_SELECT_OBJECT_4") );
 498     return false ;
 499   }
 500   MESSAGE("Fin de CreateOrUpdateBoundaryAn");
 501 }
 502 // ------------------------------------------------------------------------
 503 void SMESH_CreateBoundaryAn::PushOnOK()
 504 // ------------------------------------------------------------------------
 505 {
 506      if (PushOnApply()) this->close();
 507 }
 508 // ------------------------------------------------------------------------
 509 void SMESH_CreateBoundaryAn::PushOnHelp()
 510 // ------------------------------------------------------------------------
 511 {
 512   SMESH::ShowHelpFile(QString("homard_create_boundary.html#analytical-boundary"));
 513 }
 514
 515 // -----------------------------------
 516 void SMESH_CreateBoundaryAn::SetNewName()
 517 // -----------------------------------
 518 {
 519 // Recherche d'un nom par defaut qui n'existe pas encore
 520
 521   SMESHHOMARD::listeBoundarys_var MyObjects = myHomardGen->GetAllBoundarysName();
 522   int num = 0; QString aName="";
 523   while (aName=="" )
 524   {
 525     aName.setNum(num+1) ;
 526     aName.insert(0, QString("Boun_")) ;
 527     for ( int i=0; i<MyObjects->length(); i++)
 528     {
 529       if ( aName ==  QString(MyObjects[i]))
 530       {
 531         num ++ ;
 532         aName = "" ;
 533         break ;
 534       }
 535    }
 536   }
 537   LEName->setText(aName);
 538 }
 539 // ------------------------------------------------------------------------
 540 void SMESH_CreateBoundaryAn::SetCylinder()
 541 // ------------------------------------------------------------------------
 542 {
 543   MESSAGE("Debut de SetCylinder")
 544   gBCylindre->setVisible(1);
 545   gBSphere->setVisible(0);
 546   gBCone->setVisible(0);
 547   gBTore->setVisible(0);
 548 //
 549   _Type=1;
 550 //
 551   adjustSize();
 552 //   MESSAGE("Fin de SetCylinder")
 553 }
 554 // ------------------------------------------------------------------------
 555 void SMESH_CreateBoundaryAn::SetSphere()
 556 // ------------------------------------------------------------------------
 557 {
 558   MESSAGE("Debut de SetSphere")
 559   gBCylindre->setVisible(0);
 560   gBSphere->setVisible(1);
 561   gBCone->setVisible(0);
 562   gBTore->setVisible(0);
 563 //
 564   _Type=2;
 565 //
 566   adjustSize();
 567 //   MESSAGE("Fin de SetSphere")
 568 }
 569 // ------------------------------------------------------------------------
 570 void SMESH_CreateBoundaryAn::SetConeR()
 571 // ------------------------------------------------------------------------
 572 {
 573   MESSAGE("Debut de SetConeR")
 574 //
 575 // Stockage et conversion des valeurs si elles ont change
 576   if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value())  ||
 577       (_BoundaryAnYaxisCone != SpinBox_Cone_Y1->value())  ||
 578       (_BoundaryAnZaxisCone != SpinBox_Cone_Z1->value())  ||
 579       (_BoundaryAnXorigCone != SpinBox_Cone_X2->value())  ||
 580       (_BoundaryAnYorigCone != SpinBox_Cone_Y2->value())  ||
 581       (_BoundaryAnZorigCone != SpinBox_Cone_Z2->value())  ||
 582       (_BoundaryAngle       != SpinBox_Cone_V1->value()) )
 583   {
 584     MESSAGE("Stockage et conversion")
 585     _BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
 586     _BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
 587     _BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
 588     _BoundaryAnXorigCone = SpinBox_Cone_X2->value() ;
 589     _BoundaryAnYorigCone = SpinBox_Cone_Y2->value() ;
 590     _BoundaryAnZorigCone = SpinBox_Cone_Z2->value() ;
 591     _BoundaryAngle       = SpinBox_Cone_V1->value() ;
 592     convertRayonAngle(-1) ;
 593   }
 594 //
 595   _Type=4;
 596 //
 597   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X centre 1", 0));
 598   SpinBox_Cone_X1->setValue(_BoundaryAnXcone1);
 599   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y centre 1", 0));
 600   SpinBox_Cone_Y1->setValue(_BoundaryAnYcone1);
 601   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z centre 1", 0));
 602   SpinBox_Cone_Z1->setValue(_BoundaryAnZcone1);
 603 //
 604   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Radius 1", 0));
 605   SpinBox_Cone_V1->setSingleStep(_Rayon/10.);
 606   SpinBox_Cone_V1->setMaximum(100000.*_DMax);
 607   SpinBox_Cone_V1->setValue(_BoundaryAnRayon1);
 608 //
 609   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre 2", 0));
 610   SpinBox_Cone_X2->setValue(_BoundaryAnXcone2);
 611   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre 2", 0));
 612   SpinBox_Cone_Y2->setValue(_BoundaryAnYcone2);
 613   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre 2", 0));
 614   SpinBox_Cone_Z2->setValue(_BoundaryAnZcone2);
 615 //
 616   TLCone_V2->setVisible(1);
 617   SpinBox_Cone_V2->setVisible(1);
 618   TLCone_V2->setText(QApplication::translate("CreateBoundaryAn", "Radius 2", 0));
 619   SpinBox_Cone_V2->setValue(_BoundaryAnRayon2);
 620 //
 621 //   MESSAGE("Fin de SetConeR")
 622 }
 623 // ------------------------------------------------------------------------
 624 void SMESH_CreateBoundaryAn::SetConeA()
 625 // ------------------------------------------------------------------------
 626 {
 627   MESSAGE("Debut de SetConeA")
 628 // Stockage et conversion des valeurs si elles ont change
 629   if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value())  ||
 630       (_BoundaryAnYcone1 != SpinBox_Cone_Y1->value())  ||
 631       (_BoundaryAnZcone1 != SpinBox_Cone_Z1->value())  ||
 632       (_BoundaryAnRayon1 != SpinBox_Cone_V1->value())  ||
 633       (_BoundaryAnXcone2 != SpinBox_Cone_X2->value())  ||
 634       (_BoundaryAnYcone2 != SpinBox_Cone_Y2->value())  ||
 635       (_BoundaryAnZcone2 != SpinBox_Cone_Z2->value())  ||
 636       (_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
 637   {
 638     MESSAGE("Stockage et conversion")
 639     _BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
 640     _BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
 641     _BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
 642     _BoundaryAnRayon1 = SpinBox_Cone_V1->value() ;
 643     _BoundaryAnXcone2 = SpinBox_Cone_X2->value() ;
 644     _BoundaryAnYcone2 = SpinBox_Cone_Y2->value() ;
 645     _BoundaryAnZcone2 = SpinBox_Cone_Z2->value() ;
 646     _BoundaryAnRayon2 = SpinBox_Cone_V2->value() ;
 647     convertRayonAngle(1) ;
 648   }
 649 //
 650   _Type=3;
 651 //
 652   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X axis", 0));
 653   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
 654   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y axis", 0));
 655   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
 656   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z axis", 0));
 657   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
 658 //
 659   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre", 0));
 660   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
 661   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre", 0));
 662   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
 663   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre", 0));
 664   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
 665 //
 666   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Angle", 0));
 667   SpinBox_Cone_V1->setValue(_BoundaryAngle);
 668   SpinBox_Cone_V1->setSingleStep(1.);
 669   SpinBox_Cone_V1->setMaximum(90.);
 670 //
 671   TLCone_V2->setVisible(0);
 672   SpinBox_Cone_V2->setVisible(0);
 673 //   MESSAGE("Fin de SetConeA")
 674 }
 675
 676
 677 // ------------------------------------------------------------------------
 678 void SMESH_CreateBoundaryAn::SetCone()
 679 // ------------------------------------------------------------------------
 680 {
 681   MESSAGE("Debut de SetCone")
 682   gBCylindre->setVisible(0);
 683   gBSphere->setVisible(0);
 684   gBCone->setVisible(1);
 685   gBTore->setVisible(0);
 686 //
 687   if ( RB_Def_radius->isChecked() )
 688   {
 689     SetConeR();
 690   }
 691   else
 692   {
 693     SetConeA();
 694   }
 695 //
 696   adjustSize();
 697 //   MESSAGE("Fin de SetCone")
 698 }
 699 // ------------------------------------------------------------------------
 700 void SMESH_CreateBoundaryAn::SetTore()
 701 // ------------------------------------------------------------------------
 702 {
 703   MESSAGE("Debut de SetTore")
 704   gBCylindre->setVisible(0);
 705   gBSphere->setVisible(0);
 706   gBCone->setVisible(0);
 707   gBTore->setVisible(1);
 708 //
 709   _Type=5;
 710 //
 711   adjustSize();
 712 //   MESSAGE("Fin de SetTore")
 713 }
 714 // ------------------------------------------------------------------------
 715 void SMESH_CreateBoundaryAn::convertRayonAngle(int option)
 716 // ------------------------------------------------------------------------
 717 // Conversion entre les deux formulations du cone :
 718 // par deux rayons ou avec un axe et un angle.
 719 // Voir sfcoi1 de HOMARD
 720 {
 721   MESSAGE("Debut de convertRayonAngle, option = "<<option)
 722 //
 723 //         o
 724 //         !    .
 725 //         !        .
 726 //       RA!            .
 727 //         !                o
 728 //         !              RB!   .
 729 //         !                !       .
 730 //         A----------------B----------O
 731 //
 732 //   Thales : RA/RB = AO/BO  ==> BO = AB*RB/(RA-RB)
 733 //   Angle  : tg(alpha) = RA/AO
 734 //
 735   double daux ;
 736 // De rayon vers angle :
 737   if ( option == 1 )
 738   {
 739     double xa, ya, za, ra ;
 740     double xb, yb, zb, rb ;
 741 // Positionnement de A vers B, avec RA>RB
 742     if ( _BoundaryAnRayon1 > _BoundaryAnRayon2 )
 743     {
 744       xa = _BoundaryAnXcone1 ;
 745       ya = _BoundaryAnYcone1 ;
 746       za = _BoundaryAnZcone1 ;
 747       ra = _BoundaryAnRayon1 ;
 748       xb = _BoundaryAnXcone2 ;
 749       yb = _BoundaryAnYcone2 ;
 750       zb = _BoundaryAnZcone2 ;
 751       rb = _BoundaryAnRayon2 ;
 752     }
 753     else
 754     {
 755       xa = _BoundaryAnXcone2 ;
 756       ya = _BoundaryAnYcone2 ;
 757       za = _BoundaryAnZcone2 ;
 758       ra = _BoundaryAnRayon2 ;
 759       xb = _BoundaryAnXcone1 ;
 760       yb = _BoundaryAnYcone1 ;
 761       zb = _BoundaryAnZcone1 ;
 762       rb = _BoundaryAnRayon1 ;
 763     }
 764 // Axe : relie les deux centres, de A vers B.  L'axe est normalise
 765     _BoundaryAnXaxisCone = xb - xa ;
 766     _BoundaryAnYaxisCone = yb - ya ;
 767     _BoundaryAnZaxisCone = zb - za ;
 768     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 769     _BoundaryAnXaxisCone = _BoundaryAnXaxisCone/daux ;
 770     _BoundaryAnYaxisCone = _BoundaryAnYaxisCone/daux ;
 771     _BoundaryAnZaxisCone = _BoundaryAnZaxisCone/daux ;
 772 // Origine
 773     daux = daux * rb / (ra-rb) ;
 774     _BoundaryAnXorigCone = xb + daux*_BoundaryAnXaxisCone ;
 775     _BoundaryAnYorigCone = yb + daux*_BoundaryAnYaxisCone ;
 776     _BoundaryAnZorigCone = zb + daux*_BoundaryAnZaxisCone ;
 777 // Angle en degre
 778     daux = ra / sqrt((_BoundaryAnXorigCone-xa)*(_BoundaryAnXorigCone-xa) + (_BoundaryAnYorigCone-ya)*(_BoundaryAnYorigCone-ya) + (_BoundaryAnZorigCone-za)*(_BoundaryAnZorigCone-za) ) ;
 779     _BoundaryAngle = atan(daux)*180./PI ;
 780   }
 781 // D'angle vers rayon :
 782   else
 783   {
 784     double xax, yax, zax ;
 785 // L'axe est normalise
 786     daux = sqrt ( _BoundaryAnXaxisCone*_BoundaryAnXaxisCone + _BoundaryAnYaxisCone*_BoundaryAnYaxisCone + _BoundaryAnZaxisCone*_BoundaryAnZaxisCone ) ;
 787     xax = _BoundaryAnXaxisCone/daux ;
 788     yax = _BoundaryAnYaxisCone/daux ;
 789     zax = _BoundaryAnZaxisCone/daux ;
 790 // Centre 1 : l'origine
 791     _BoundaryAnXcone1 = _BoundaryAnXorigCone ;
 792     _BoundaryAnYcone1 = _BoundaryAnYorigCone ;
 793     _BoundaryAnZcone1 = _BoundaryAnZorigCone ;
 794 // Rayon 1 : nul
 795     _BoundaryAnRayon1 = 0. ;
 796 // Centre 2 : l'origine decalee d'une longueur arbitraire le long de l'axe
 797     _BoundaryAnXcone2 = _BoundaryAnXorigCone + _DMax*xax ;
 798     _BoundaryAnYcone2 = _BoundaryAnYorigCone + _DMax*yax ;
 799     _BoundaryAnZcone2 = _BoundaryAnZorigCone + _DMax*zax ;
 800 // Rayon 2 : a calculer
 801     _BoundaryAnRayon2 = _DMax*tan(_BoundaryAngle*PI/180.) ;
 802   }
 803 //   MESSAGE("Fin de convertRayonAngle")
 804 }
 805
 806 // -------------------------------------------------------------------------------
 807 SMESH_CreateBoundaryCAO::SMESH_CreateBoundaryCAO(SMESHGUI_HomardAdaptDlg* parent, bool modal,
 808                                                  SMESHHOMARD::HOMARD_Gen_var myHomardGen0,
 809                                                  QString caseName, QString aName)
 810 // ---------------------------------------------------------------------------------
 811 /* Constructs a SMESH_CreateBoundaryCAO */
 812     :
 813     QDialog(0), SMESH_Ui_CreateBoundaryCAO(),
 814     _parent(parent), _aName(aName),
 815     myHomardGen(SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen0))
 816     {
 817       MESSAGE("Constructeur") ;
 818       setupUi(this);
 819       setModal(modal);
 820       InitConnect();
 821
 822      if ( _aName == QString("") ) {SetNewName();};
 823     }
 824
 825 // ------------------------------------------------------------------------
 826 SMESH_CreateBoundaryCAO::~SMESH_CreateBoundaryCAO()
 827 // ------------------------------------------------------------------------
 828 {
 829     // no need to delete child widgets, Qt does it all for us
 830 }
 831 // ------------------------------------------------------------------------
 832 void SMESH_CreateBoundaryCAO::InitConnect()
 833 // ------------------------------------------------------------------------
 834 {
 835     connect( PushFichier,  SIGNAL(pressed()), this, SLOT(SetCAOFile()));
 836     connect( buttonOk,     SIGNAL(pressed()), this, SLOT( PushOnOK()));
 837     connect( buttonApply,  SIGNAL(pressed()), this, SLOT( PushOnApply()));
 838     connect( buttonCancel, SIGNAL(pressed()), this, SLOT(close()));
 839     connect( buttonHelp,   SIGNAL(pressed()), this, SLOT( PushOnHelp()));
 840     connect( CBGroupe,     SIGNAL(stateChanged(int)), this, SLOT( SetFiltrage()));
 841 }
 842
 843 // ------------------------------------------------------------------------
 844 bool SMESH_CreateBoundaryCAO::PushOnApply()
 845 // ------------------------------------------------------------------------
 846 // Appele lorsque l'un des boutons Ok ou Apply est presse
 847 //
 848 {
 849 // Verifications
 850
 851   QString aName=LEName->text().trimmed();
 852   if (aName=="") {
 853     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 854                               QObject::tr("HOM_BOUN_NAME") );
 855     return false;
 856   }
 857
 858 //  La CAO
 859   QString aCAOFile=LEFileName->text().trimmed();
 860   if (aCAOFile ==QString(""))
 861   {
 862     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 863                               QObject::tr("HOM_BOUN_CAO") );
 864     return false;
 865   }
 866
 867 // Creation de l'objet CORBA si ce n'est pas deja fait sous le meme nom
 868   if ( _aName != aName )
 869   {
 870    try
 871    {
 872      _aName=aName;
 873      aBoundary=myHomardGen->CreateBoundaryCAO(CORBA::string_dup(_aName.toStdString().c_str()), aCAOFile.toStdString().c_str());
 874      _parent->AddBoundaryCAO(_aName);
 875    }
 876    catch( SALOME::SALOME_Exception& S_ex )
 877    {
 878       QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
 879                                 QObject::tr(CORBA::string_dup(S_ex.details.text)) );
 880       return false;
 881    }
 882   }
 883
 884 // Les groupes
 885   AssocieLesGroupes();
 886
 887   //HOMARD_UTILS::updateObjBrowser();
 888   return true;
 889 }
 890
 891
 892 // ------------------------------------------------------------------------
 893 void SMESH_CreateBoundaryCAO::PushOnOK()
 894 // ------------------------------------------------------------------------
 895 {
 896      if (PushOnApply()) this->close();
 897      if ( _parent ) { _parent->raise(); _parent->activateWindow(); };
 898 }
 899 // ------------------------------------------------------------------------
 900 void SMESH_CreateBoundaryCAO::PushOnHelp()
 901 // ------------------------------------------------------------------------
 902 {
 903   SMESH::ShowHelpFile(QString("homard_create_boundary.html#cao-boundary"));
 904 }
 905 // ------------------------------------------------------------------------
 906 void SMESH_CreateBoundaryCAO::AssocieLesGroupes()
 907 // ------------------------------------------------------------------------
 908 {
 909   SMESHHOMARD::ListGroupType_var aSeqGroupe = new SMESHHOMARD::ListGroupType;
 910   aSeqGroupe->length(_listeGroupesBoundary.size());
 911   QStringList::const_iterator it;
 912   int i=0;
 913   for (it = _listeGroupesBoundary.constBegin(); it != _listeGroupesBoundary.constEnd(); it++)
 914      aSeqGroupe[i++]=(*it).toStdString().c_str();
 915   aBoundary->SetGroups(aSeqGroupe);
 916
 917 }
 918
 919 // -------------------------------------------------
 920 void SMESH_CreateBoundaryCAO::SetNewName()
 921 // --------------------------------------------------
 922 {
 923
 924   SMESHHOMARD::listeBoundarys_var  MyObjects = myHomardGen->GetAllBoundarysName();
 925   int num = 0; QString aName="";
 926   while (aName == QString("") )
 927   {
 928     aName.setNum(num+1) ;
 929     aName.insert(0, QString("Boun_")) ;
 930     for ( int i=0; i<MyObjects->length(); i++)
 931     {
 932       if ( aName ==  QString(MyObjects[i]))
 933       {
 934         num ++ ;
 935         aName = "" ;
 936         break ;
 937       }
 938    }
 939   }
 940   LEName->setText(aName);
 941 }
 942 // ------------------------------------------------------------------------
 943 void SMESH_CreateBoundaryCAO::SetCAOFile()
 944 // ------------------------------------------------------------------------
 945 {
 946   QString aCAOFile = SMESH_HOMARD_QT_COMMUN::PushNomFichier( false, QString("xao") );
 947   if (!(aCAOFile.isEmpty())) LEFileName->setText(aCAOFile);
 948 }
 949
 950 // ------------------------------------------------------------------------
 951 void SMESH_CreateBoundaryCAO::setGroups (QStringList listGroup)
 952 // ------------------------------------------------------------------------
 953 {
 954     _listeGroupesBoundary = listGroup;
 955 }
 956 // ------------------------------------------------------------------------
 957 void SMESH_CreateBoundaryCAO::SetFiltrage()
 958 // ------------------------------------------------------------------------
 959 {
 960   if (!CBGroupe->isChecked()) return;
 961
 962   SMESH_CreateListGroupCAO *aDlg = new SMESH_CreateListGroupCAO
 963     (this, true, SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen),
 964      "Case_1", _listeGroupesBoundary);
 965   aDlg->show();
 966 }
 967
 968 // -------------------------------------------------------------------------------
 969 SMESH_CreateBoundaryDi::SMESH_CreateBoundaryDi(SMESHGUI_HomardAdaptDlg* parent, bool modal,
 970                                                SMESHHOMARD::HOMARD_Gen_var myHomardGen0,
 971                                                QString caseName, QString aName)
 972 // ---------------------------------------------------------------------------------
 973 /* Constructs a SMESH_CreateBoundaryDi */
 974     :
 975     QDialog(0), SMESH_Ui_CreateBoundaryDi(),
 976     _parent(parent), _aName(aName),
 977     myHomardGen(SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen0))
 978     {
 979       MESSAGE("Constructeur") ;
 980       setupUi(this);
 981       setModal(modal);
 982       InitConnect();
 983
 984      if ( _aName == QString("") ) {SetNewName();};
 985     }
 986
 987 // ------------------------------------------------------------------------
 988 SMESH_CreateBoundaryDi::~SMESH_CreateBoundaryDi()
 989 // ------------------------------------------------------------------------
 990 {
 991     // no need to delete child widgets, Qt does it all for us
 992 }
 993 // ------------------------------------------------------------------------
 994 void SMESH_CreateBoundaryDi::InitConnect()
 995 // ------------------------------------------------------------------------
 996 {
 997     connect( PushFichier,  SIGNAL(pressed()), this, SLOT(SetMeshFile()));
 998     connect( buttonOk,     SIGNAL(pressed()), this, SLOT( PushOnOK()));
 999     connect( buttonApply,  SIGNAL(pressed()), this, SLOT( PushOnApply()));
1000     connect( buttonCancel, SIGNAL(pressed()), this, SLOT(close()));
1001     connect( buttonHelp,   SIGNAL(pressed()), this, SLOT( PushOnHelp()));
1002     connect( CBGroupe,     SIGNAL(stateChanged(int)), this, SLOT( SetFiltrage()));
1003 }
1004
1005 // ------------------------------------------------------------------------
1006 bool SMESH_CreateBoundaryDi::PushOnApply()
1007 // ------------------------------------------------------------------------
1008 // Appele lorsque l'un des boutons Ok ou Apply est presse
1009 //
1010 {
1011 // Verifications
1012
1013   QString aName=LEName->text().trimmed();
1014   if (aName=="") {
1015     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
1016                               QObject::tr("HOM_BOUN_NAME") );
1017     return false;
1018   }
1019
1020 //  Le maillage de la frontiere discrete
1021   QString aMeshFile=LEFileName->text().trimmed();
1022   if (aMeshFile ==QString(""))
1023   {
1024     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
1025                               QObject::tr("HOM_BOUN_MESH") );
1026     return false;
1027   }
1028
1029   //  Le nom du maillage de la frontiere discrete
1030   QString aMeshName = SMESH_HOMARD_QT_COMMUN::LireNomMaillage(aMeshFile);
1031   if (aMeshName == "" )
1032   {
1033     QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
1034                               QObject::tr("HOM_MED_FILE_2") );
1035     return false;
1036   }
1037
1038 // Creation de l'objet CORBA si ce n'est pas deja fait sous le meme nom
1039   if ( _aName != aName )
1040   {
1041    try
1042    {
1043      _aName=aName;
1044      aBoundary=myHomardGen->CreateBoundaryDi(CORBA::string_dup(_aName.toStdString().c_str()), aMeshName.toStdString().c_str(), aMeshFile.toStdString().c_str());
1045      _parent->AddBoundaryDi(_aName);
1046    }
1047    catch( SALOME::SALOME_Exception& S_ex )
1048    {
1049       QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
1050                                 QObject::tr(CORBA::string_dup(S_ex.details.text)) );
1051       return false;
1052    }
1053   }
1054
1055 // Les groupes
1056   AssocieLesGroupes();
1057
1058   //HOMARD_UTILS::updateObjBrowser();
1059   return true;
1060 }
1061
1062
1063 // ------------------------------------------------------------------------
1064 void SMESH_CreateBoundaryDi::PushOnOK()
1065 // ------------------------------------------------------------------------
1066 {
1067      if (PushOnApply()) this->close();
1068      if ( _parent ) { _parent->raise(); _parent->activateWindow(); };
1069 }
1070 // ------------------------------------------------------------------------
1071 void SMESH_CreateBoundaryDi::PushOnHelp()
1072 // ------------------------------------------------------------------------
1073 {
1074   SMESH::ShowHelpFile(QString("homard_create_boundary.html#discrete-boundary"));
1075 }
1076 // ------------------------------------------------------------------------
1077 void SMESH_CreateBoundaryDi::AssocieLesGroupes()
1078 // ------------------------------------------------------------------------
1079 {
1080   SMESHHOMARD::ListGroupType_var aSeqGroupe = new SMESHHOMARD::ListGroupType;
1081   aSeqGroupe->length(_listeGroupesBoundary.size());
1082   QStringList::const_iterator it;
1083   int i=0;
1084   for (it = _listeGroupesBoundary.constBegin(); it != _listeGroupesBoundary.constEnd(); it++)
1085      aSeqGroupe[i++]=(*it).toStdString().c_str();
1086   aBoundary->SetGroups(aSeqGroupe);
1087
1088 }
1089
1090 // -------------------------------------------------
1091 void SMESH_CreateBoundaryDi::SetNewName()
1092 // --------------------------------------------------
1093 {
1094
1095   SMESHHOMARD::listeBoundarys_var  MyObjects = myHomardGen->GetAllBoundarysName();
1096   int num = 0; QString aName="";
1097   while (aName == QString("") )
1098   {
1099     aName.setNum(num+1) ;
1100     aName.insert(0, QString("Boun_")) ;
1101     for ( int i=0; i<MyObjects->length(); i++)
1102     {
1103       if ( aName ==  QString(MyObjects[i]))
1104       {
1105         num ++ ;
1106         aName = "" ;
1107         break ;
1108       }
1109    }
1110   }
1111   LEName->setText(aName);
1112 }
1113 // ------------------------------------------------------------------------
1114 void SMESH_CreateBoundaryDi::SetMeshFile()
1115 // ------------------------------------------------------------------------
1116 {
1117   QString aMeshFile = SMESH_HOMARD_QT_COMMUN::PushNomFichier( false, QString("med") );
1118   if (!(aMeshFile.isEmpty())) LEFileName->setText(aMeshFile);
1119 }
1120
1121 // ------------------------------------------------------------------------
1122 void SMESH_CreateBoundaryDi::setGroups (QStringList listGroup)
1123 // ------------------------------------------------------------------------
1124 {
1125     _listeGroupesBoundary = listGroup;
1126 }
1127 // ------------------------------------------------------------------------
1128 void SMESH_CreateBoundaryDi::SetFiltrage()
1129 // // ------------------------------------------------------------------------
1130 {
1131   if (!CBGroupe->isChecked()) return;
1132
1133   SMESH_CreateListGroup *aDlg = new SMESH_CreateListGroup
1134     (this, true, SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen),
1135      "Case_1", _listeGroupesBoundary);
1136   aDlg->show();
1137 }
1138
1139 // ------------------------------------------------------------------------
1140 SMESH_EditBoundaryAn::SMESH_EditBoundaryAn( SMESHGUI_HomardAdaptDlg* parent, bool modal,
1141                                             SMESHHOMARD::HOMARD_Gen_var myHomardGen0,
1142                                             QString caseName, QString Name ):
1143 // ------------------------------------------------------------------------
1144 /* Constructs a SMESH_EditBoundaryAn
1145     herite de SMESH_CreateBoundaryAn
1146 */
1147     SMESH_CreateBoundaryAn(parent, myHomardGen0, caseName)
1148 {
1149     MESSAGE("Debut de SMESH_EditBoundaryAn pour " << Name.toStdString().c_str());
1150     setWindowTitle(QObject::tr("HOM_BOUN_A_EDIT_WINDOW_TITLE"));
1151     _Name=Name;
1152     aBoundaryAn = myHomardGen->GetBoundary(_Name.toStdString().c_str());
1153     InitValEdit();
1154 }
1155 // ------------------------------------------------------------------------
1156 SMESH_EditBoundaryAn::~SMESH_EditBoundaryAn()
1157 // ------------------------------------------------------------------------
1158 {
1159     // no need to delete child widgets, Qt does it all for us
1160 }
1161 // ------------------------------------------------------------------------
1162 void SMESH_EditBoundaryAn::InitValEdit()
1163 // ------------------------------------------------------------------------
1164 {
1165   LEName->setText(_Name);
1166   LEName->setReadOnly(true);
1167   _Type = aBoundaryAn->GetType();
1168   MESSAGE("_Type : "<<_Type);
1169   InitValBoundaryAnLimit();
1170   InitValBoundaryAn();
1171   switch (_Type)
1172   {
1173     case 1 : // il s agit d un cylindre
1174     {
1175       InitValBoundaryAnCylindre();
1176       SetCylinder();
1177       break;
1178     }
1179     case 2: // il s agit d une sphere
1180     {
1181       InitValBoundaryAnSphere();
1182       SetSphere();
1183       break;
1184     }
1185     case 3: // il s agit d un cone defini par un axe et un angle
1186     {
1187       InitValBoundaryAnConeA();
1188       SetConeA();
1189       break;
1190     }
1191     case 4: // il s agit d un cone defini par les 2 rayons
1192     {
1193       InitValBoundaryAnConeR();
1194       SetConeR();
1195       break;
1196     }
1197     case 5: // il s agit d un tore
1198     {
1199       InitValBoundaryAnTore();
1200       SetTore();
1201       break;
1202     }
1203   };
1204 }
1205 // ------------------------------------------------------------------------
1206 void SMESH_EditBoundaryAn::InitValBoundaryAnLimit()
1207 // ------------------------------------------------------------------------
1208 {
1209   SMESHHOMARD::double_array_var  mesCoordLimits = aBoundaryAn->GetLimit();
1210   ASSERT(mesCoordLimits->length() == 3 );
1211   _Xincr=mesCoordLimits[0];
1212   _Yincr=mesCoordLimits[1];
1213   _Zincr=mesCoordLimits[2];
1214 }
1215 // ------------------------------------------------------------------------
1216 void SMESH_EditBoundaryAn::InitValBoundaryAnCylindre()
1217 // ------------------------------------------------------------------------
1218 {
1219   SMESHHOMARD::double_array_var  mesCoordBoundary = aBoundaryAn->GetCoords();
1220   ASSERT(mesCoordBoundary->length() == 7 );
1221   _BoundaryAnXcentre=mesCoordBoundary[0];
1222   _BoundaryAnYcentre=mesCoordBoundary[1];
1223   _BoundaryAnZcentre=mesCoordBoundary[2];
1224   _BoundaryAnXaxis=mesCoordBoundary[3];
1225   _BoundaryAnYaxis=mesCoordBoundary[4];
1226   _BoundaryAnZaxis=mesCoordBoundary[5];
1227   _BoundaryAnRayon=mesCoordBoundary[6];
1228 }
1229 // ------------------------------------------------------------------------
1230 void SMESH_EditBoundaryAn::InitValBoundaryAnSphere()
1231 // ------------------------------------------------------------------------
1232 {
1233   SMESHHOMARD::double_array_var  mesCoordBoundary = aBoundaryAn->GetCoords();
1234   ASSERT(mesCoordBoundary->length() == 4 );
1235   _BoundaryAnXcentre=mesCoordBoundary[0];
1236   _BoundaryAnYcentre=mesCoordBoundary[1];
1237   _BoundaryAnZcentre=mesCoordBoundary[2];
1238   _BoundaryAnRayon=mesCoordBoundary[3];
1239 }
1240 // ------------------------------------------------------------------------
1241 void SMESH_EditBoundaryAn::InitValBoundaryAnConeA()
1242 // ------------------------------------------------------------------------
1243 {
1244   SMESHHOMARD::double_array_var  mesCoordBoundary = aBoundaryAn->GetCoords();
1245   ASSERT(mesCoordBoundary->length() == 7 );
1246   _BoundaryAnXaxisCone=mesCoordBoundary[0];
1247   _BoundaryAnYaxisCone=mesCoordBoundary[1];
1248   _BoundaryAnZaxisCone=mesCoordBoundary[2];
1249   _BoundaryAngle=mesCoordBoundary[3];
1250   _BoundaryAnXorigCone=mesCoordBoundary[4];
1251   _BoundaryAnYorigCone=mesCoordBoundary[5];
1252   _BoundaryAnZorigCone=mesCoordBoundary[6];
1253   convertRayonAngle(-1) ;
1254 }
1255 // ------------------------------------------------------------------------
1256 void SMESH_EditBoundaryAn::InitValBoundaryAnConeR()
1257 // ------------------------------------------------------------------------
1258 {
1259   SMESHHOMARD::double_array_var  mesCoordBoundary = aBoundaryAn->GetCoords();
1260   ASSERT(mesCoordBoundary->length() == 8 );
1261   _BoundaryAnXcone1=mesCoordBoundary[0];
1262   _BoundaryAnYcone1=mesCoordBoundary[1];
1263   _BoundaryAnZcone1=mesCoordBoundary[2];
1264   _BoundaryAnRayon1=mesCoordBoundary[3];
1265   _BoundaryAnXcone2=mesCoordBoundary[4];
1266   _BoundaryAnYcone2=mesCoordBoundary[5];
1267   _BoundaryAnZcone2=mesCoordBoundary[6];
1268   _BoundaryAnRayon2=mesCoordBoundary[7];
1269   convertRayonAngle(1) ;
1270 }
1271 // ------------------------------------------------------------------------
1272 void SMESH_EditBoundaryAn::InitValBoundaryAnTore()
1273 // ------------------------------------------------------------------------
1274 {
1275   SMESHHOMARD::double_array_var  mesCoordBoundary = aBoundaryAn->GetCoords();
1276   ASSERT(mesCoordBoundary->length() == 8 );
1277   _BoundaryAnXcentre=mesCoordBoundary[0];
1278   _BoundaryAnYcentre=mesCoordBoundary[1];
1279   _BoundaryAnZcentre=mesCoordBoundary[2];
1280   _BoundaryAnXaxis=mesCoordBoundary[3];
1281   _BoundaryAnYaxis=mesCoordBoundary[4];
1282   _BoundaryAnZaxis=mesCoordBoundary[5];
1283   _BoundaryAnRayon1=mesCoordBoundary[6];
1284   _BoundaryAnRayon2=mesCoordBoundary[7];
1285 }
1286 // ------------------------------------------------------------------------
1287 void SMESH_EditBoundaryAn::SetCylinder()
1288 // ------------------------------------------------------------------------
1289 {
1290   gBCylindre->setVisible(1);
1291   gBSphere->setVisible(0);
1292   gBCone->setVisible(0);
1293   gBTore->setVisible(0);
1294   RBCylindre->setChecked(1);
1295   _Type=1;
1296   RBSphere->setDisabled(true);
1297   RBCone->setDisabled(true);
1298   RBTore->setDisabled(true);
1299
1300   SpinBox_Xcent->setValue(_BoundaryAnXcentre);
1301   SpinBox_Ycent->setValue(_BoundaryAnYcentre);
1302   SpinBox_Zcent->setValue(_BoundaryAnZcentre);
1303
1304   SpinBox_Xaxis->setValue(_BoundaryAnXaxis);
1305   SpinBox_Yaxis->setValue(_BoundaryAnYaxis);
1306   SpinBox_Zaxis->setValue(_BoundaryAnZaxis);
1307
1308
1309   SpinBox_Xaxis->setSingleStep(0.1);
1310   SpinBox_Xcentre->setSingleStep(_Xincr);
1311   SpinBox_Yaxis->setSingleStep(0.1);
1312   SpinBox_Ycentre->setSingleStep(_Yincr);
1313   SpinBox_Zaxis->setSingleStep(0.1);
1314   SpinBox_Zcentre->setSingleStep(_Zincr);
1315 // Rayon
1316   SpinBox_Radius->setValue(_BoundaryAnRayon);
1317   SpinBox_Radius->setSingleStep(_BoundaryAnRayon/10.);
1318 //
1319   adjustSize();
1320 }
1321 // ------------------------------------------------------------------------
1322 void SMESH_EditBoundaryAn::SetSphere()
1323 // ------------------------------------------------------------------------
1324 {
1325   gBCylindre->setVisible(0);
1326   gBSphere->setVisible(1);
1327   RBSphere->setChecked(1);
1328   gBCone->setVisible(0);
1329   gBTore->setVisible(0);
1330   RBCylindre->setDisabled(true);
1331   RBCone->setDisabled(true);
1332   RBTore->setDisabled(true);
1333   _Type=2 ;
1334
1335   SpinBox_Xcentre->setValue(_BoundaryAnXcentre);
1336   if ( _Xincr > 0) { SpinBox_Xcentre->setSingleStep(_Xincr); }
1337   else             { SpinBox_Xcentre->setSingleStep(1) ; }
1338
1339   SpinBox_Ycentre->setValue(_BoundaryAnYcentre);
1340   if ( _Yincr > 0) { SpinBox_Ycentre->setSingleStep(_Yincr); }
1341   else             { SpinBox_Ycentre->setSingleStep(1) ; }
1342
1343   SpinBox_Zcentre->setValue(_BoundaryAnZcentre);
1344   if ( _Zincr > 0) { SpinBox_Zcentre->setSingleStep(_Zincr); }
1345   else             { SpinBox_Zcentre->setSingleStep(1);}
1346
1347   SpinBox_Rayon->setValue(_BoundaryAnRayon);
1348 //
1349   adjustSize();
1350 }
1351 // ------------------------------------------------------------------------
1352 void SMESH_EditBoundaryAn::SetConeA()
1353 // ------------------------------------------------------------------------
1354 {
1355   gBCylindre->setVisible(0);
1356   gBSphere->setVisible(0);
1357   gBCone->setVisible(1);
1358   RBCone->setChecked(1);
1359   gBTore->setVisible(0);
1360   RB_Def_angle->setChecked(1);
1361   RBCylindre->setDisabled(true);
1362   RBSphere->setDisabled(true);
1363   RBTore->setDisabled(true);
1364   _Type=3;
1365 //
1366   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X axis", 0));
1367   SpinBox_Cone_X1->setValue(_BoundaryAnXaxisCone);
1368   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y axis", 0));
1369   SpinBox_Cone_Y1->setValue(_BoundaryAnYaxisCone);
1370   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z axis", 0));
1371   SpinBox_Cone_Z1->setValue(_BoundaryAnZaxisCone);
1372 //
1373   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre", 0));
1374   SpinBox_Cone_X2->setValue(_BoundaryAnXorigCone);
1375   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre", 0));
1376   SpinBox_Cone_Y2->setValue(_BoundaryAnYorigCone);
1377   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre", 0));
1378   SpinBox_Cone_Z2->setValue(_BoundaryAnZorigCone);
1379 //
1380   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Angle", 0));
1381   SpinBox_Cone_V1->setValue(_BoundaryAngle);
1382   SpinBox_Cone_V1->setSingleStep(1.);
1383   SpinBox_Cone_V1->setMaximum(90.);
1384 //
1385   TLCone_V2->setVisible(0);
1386   SpinBox_Cone_V2->setVisible(0);
1387 //
1388   adjustSize();
1389 }
1390 // ------------------------------------------------------------------------
1391 void SMESH_EditBoundaryAn::SetConeR()
1392 // ------------------------------------------------------------------------
1393 {
1394   gBCylindre->setVisible(0);
1395   gBSphere->setVisible(0);
1396   gBCone->setVisible(1);
1397   gBTore->setVisible(0);
1398   RBCone->setChecked(1);
1399   RB_Def_radius->setChecked(1);
1400   RBCylindre->setDisabled(true);
1401   RBSphere->setDisabled(true);
1402   RBTore->setDisabled(true);
1403   _Type=4;
1404 //
1405   TLCone_X1->setText(QApplication::translate("CreateBoundaryAn", "X centre 1", 0));
1406   SpinBox_Cone_X1->setValue(_BoundaryAnXcone1);
1407   TLCone_Y1->setText(QApplication::translate("CreateBoundaryAn", "Y centre 1", 0));
1408   SpinBox_Cone_Y1->setValue(_BoundaryAnYcone1);
1409   TLCone_Z1->setText(QApplication::translate("CreateBoundaryAn", "Z centre 1", 0));
1410   SpinBox_Cone_Z1->setValue(_BoundaryAnZcone1);
1411 //
1412   TLCone_V1->setText(QApplication::translate("CreateBoundaryAn", "Radius 1", 0));
1413   SpinBox_Cone_V1->setSingleStep(_Rayon/10.);
1414   SpinBox_Cone_V1->setMaximum(100000.*_DMax);
1415   SpinBox_Cone_V1->setValue(_BoundaryAnRayon1);
1416 //
1417   TLCone_X2->setText(QApplication::translate("CreateBoundaryAn", "X centre 2", 0));
1418   SpinBox_Cone_X2->setValue(_BoundaryAnXcone2);
1419   TLCone_Y2->setText(QApplication::translate("CreateBoundaryAn", "Y centre 2", 0));
1420   SpinBox_Cone_Y2->setValue(_BoundaryAnYcone2);
1421   TLCone_Z2->setText(QApplication::translate("CreateBoundaryAn", "Z centre 2", 0));
1422   SpinBox_Cone_Z2->setValue(_BoundaryAnZcone2);
1423 //
1424   TLCone_V2->setVisible(1);
1425   SpinBox_Cone_V2->setVisible(1);
1426   TLCone_V2->setText(QApplication::translate("CreateBoundaryAn", "Radius 2", 0));
1427   SpinBox_Cone_V2->setValue(_BoundaryAnRayon2);
1428 //
1429   adjustSize();
1430 }
1431 // ------------------------------------------------------------------------
1432 void SMESH_EditBoundaryAn::SetTore()
1433 // ------------------------------------------------------------------------
1434 {
1435   gBCylindre->setVisible(0);
1436   gBSphere->setVisible(0);
1437   gBCone->setVisible(0);
1438   gBTore->setVisible(1);
1439   RBTore->setChecked(1);
1440   _Type=5;
1441   RBCylindre->setDisabled(true);
1442   RBSphere->setDisabled(true);
1443   RBCone->setDisabled(true);
1444
1445   SpinBoxToreXcent->setValue(_BoundaryAnXcentre);
1446   SpinBoxToreYcent->setValue(_BoundaryAnYcentre);
1447   SpinBoxToreZcent->setValue(_BoundaryAnZcentre);
1448
1449   SpinBoxToreXaxe->setValue(_BoundaryAnXaxis);
1450   SpinBoxToreYaxe->setValue(_BoundaryAnYaxis);
1451   SpinBoxToreZaxe->setValue(_BoundaryAnZaxis);
1452
1453
1454   SpinBoxToreXaxe->setSingleStep(0.1);
1455   SpinBoxToreXcent->setSingleStep(_Xincr);
1456   SpinBoxToreYaxe->setSingleStep(0.1);
1457   SpinBoxToreYcent->setSingleStep(_Yincr);
1458   SpinBoxToreZaxe->setSingleStep(0.1);
1459   SpinBoxToreZcent->setSingleStep(_Zincr);
1460 // Rayon de revolution
1461   SpinBoxToreRRev->setValue(_BoundaryAnRayon1);
1462   SpinBoxToreRRev->setSingleStep(_BoundaryAnRayon1/10.);
1463 // Rayon primaire
1464   SpinBoxToreRPri->setValue(_BoundaryAnRayon2);
1465   SpinBoxToreRPri->setSingleStep(_BoundaryAnRayon2/10.);
1466 //
1467   adjustSize();
1468 }
1469 // ---------------------------------------------------
1470 bool SMESH_EditBoundaryAn::CreateOrUpdateBoundaryAn()
1471 //----------------------------------------------------
1472 //  Mise a jour des attributs de la BoundaryAn
1473 {
1474   switch (_Type)
1475   {
1476     case 1 : // il s agit d un cylindre
1477     {
1478       aBoundaryAn->SetCylinder(_BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnXaxis, _BoundaryAnYaxis, _BoundaryAnZaxis, _BoundaryAnRayon );
1479       break;
1480     }
1481     case 2 : // il s agit d une sphere
1482     {
1483       aBoundaryAn->SetSphere(_BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnRayon);
1484       break;
1485     }
1486     case 3 : // il s agit d un cone defini par un axe et un angle
1487     {
1488       aBoundaryAn = myHomardGen->CreateBoundaryConeA(CORBA::string_dup(_Name.toStdString().c_str()), \
1489       _BoundaryAnXaxisCone, _BoundaryAnYaxisCone, _BoundaryAnZaxisCone, _BoundaryAngle, \
1490       _BoundaryAnXorigCone, _BoundaryAnYorigCone, _BoundaryAnYorigCone);
1491       break;
1492     }
1493     case 4 : // il s agit d un cone defini par les 2 rayons
1494     {
1495       aBoundaryAn = myHomardGen->CreateBoundaryConeR(CORBA::string_dup(_Name.toStdString().c_str()), \
1496         _BoundaryAnXcone1, _BoundaryAnYcone1, _BoundaryAnZcone1, _BoundaryAnRayon1, \
1497         _BoundaryAnXcone2, _BoundaryAnYcone2, _BoundaryAnZcone2, _BoundaryAnRayon2);
1498       break;
1499     }
1500     case 5 : // il s agit d un tore
1501     {
1502       aBoundaryAn->SetTorus(_BoundaryAnXcentre, _BoundaryAnYcentre, _BoundaryAnZcentre, _BoundaryAnXaxis, _BoundaryAnYaxis, _BoundaryAnZaxis, _BoundaryAnRayon1, _BoundaryAnRayon2 );
1503       break;
1504     }
1505   }
1506   if (Chgt) myHomardGen->InvalideBoundary(_Name.toStdString().c_str());
1507   //HOMARD_UTILS::updateObjBrowser();
1508   return true;
1509 }
1510
1511 // --------------------------------------------------------------------------------------
1512 /* Constructs a SMESH_EditBoundaryCAO
1513     herite de SMESH_CreateBoundaryCAO
1514 */
1515 // --------------------------------------------------------------------------------------
1516 SMESH_EditBoundaryCAO::SMESH_EditBoundaryCAO( SMESHGUI_HomardAdaptDlg* parent, bool modal,
1517                                               SMESHHOMARD::HOMARD_Gen_var myHomardGen0,
1518                                               QString caseName, QString Name):
1519     SMESH_CreateBoundaryCAO(parent, modal, myHomardGen0, caseName, Name)
1520 {
1521     MESSAGE("Debut de Boundary pour " << Name.toStdString().c_str());
1522     setWindowTitle(QObject::tr("HOM_BOUN_C_EDIT_WINDOW_TITLE"));
1523     try {
1524       aBoundary = myHomardGen->GetBoundary(CORBA::string_dup(_aName.toStdString().c_str()));
1525       InitValEdit();
1526     }
1527     catch( SALOME::SALOME_Exception& S_ex ) {
1528       QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
1529                                 QObject::tr(CORBA::string_dup(S_ex.details.text)) );
1530       return;
1531     }
1532
1533     SMESHHOMARD::ListGroupType_var maListe = aBoundary->GetGroups();
1534     for ( int i = 0; i < maListe->length(); i++ )
1535        _listeGroupesBoundary << QString(maListe[i]);
1536
1537 }
1538 // ------------------------------
1539 SMESH_EditBoundaryCAO::~SMESH_EditBoundaryCAO()
1540 // ------------------------------
1541 {
1542 }
1543 // ------------------------------
1544 void SMESH_EditBoundaryCAO::InitValEdit()
1545 // ------------------------------
1546 {
1547       LEName->setText(_aName);
1548       LEName->setReadOnly(true);
1549
1550       QString aDataFile = aBoundary->GetDataFile();
1551       LEFileName->setText(aDataFile);
1552       LEFileName->setReadOnly(1);
1553       PushFichier->setVisible(0);
1554 //
1555       adjustSize();
1556 }
1557 // ------------------------------
1558 bool SMESH_EditBoundaryCAO::PushOnApply()
1559 // ------------------------------
1560 {
1561      return true;
1562 }
1563 // ------------------------------------------------------------------------
1564 void SMESH_EditBoundaryCAO::SetFiltrage()
1565 // ------------------------------------------------------------------------
1566 {
1567   if (!CBGroupe->isChecked()) return;
1568   //SMESHHOMARD::HOMARD_Cas_var monCas = myHomardGen->GetCase();
1569   //SMESHHOMARD::ListGroupType_var _listeGroupesCas = monCas->GetGroups();
1570
1571   SMESH_EditListGroupCAO *aDlg = new SMESH_EditListGroupCAO
1572     (this, true, SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen),
1573      "Case_1", _listeGroupesBoundary) ;
1574   aDlg->show();
1575 }
1576
1577 // ------------------------------------------------------------------------------------
1578 /* Constructs a SMESH_EditBoundaryDi
1579     herite de SMESH_CreateBoundaryDi
1580 */
1581 // ------------------------------------------------------------------------------------
1582 SMESH_EditBoundaryDi::SMESH_EditBoundaryDi( SMESHGUI_HomardAdaptDlg* parent, bool modal,
1583                                             SMESHHOMARD::HOMARD_Gen_var myHomardGen0,
1584                                             QString caseName, QString Name):
1585   SMESH_CreateBoundaryDi(parent, modal, myHomardGen0, caseName, Name)
1586 {
1587     MESSAGE("Debut de Boundary pour " << Name.toStdString().c_str());
1588     setWindowTitle(QObject::tr("HOM_BOUN_D_EDIT_WINDOW_TITLE"));
1589     try {
1590       aBoundary = myHomardGen->GetBoundary(CORBA::string_dup(_aName.toStdString().c_str()));
1591       InitValEdit();
1592     }
1593     catch( SALOME::SALOME_Exception& S_ex ) {
1594       QMessageBox::critical( 0, QObject::tr("HOM_ERROR"),
1595                                 QObject::tr(CORBA::string_dup(S_ex.details.text)) );
1596       return;
1597     }
1598
1599     SMESHHOMARD::ListGroupType_var maListe = aBoundary->GetGroups();
1600     for ( int i = 0; i < maListe->length(); i++ )
1601        _listeGroupesBoundary << QString(maListe[i]);
1602
1603 }
1604 // ------------------------------
1605 SMESH_EditBoundaryDi::~SMESH_EditBoundaryDi()
1606 // ------------------------------
1607 {
1608 }
1609 // ------------------------------
1610 void SMESH_EditBoundaryDi::InitValEdit()
1611 // ------------------------------
1612 {
1613       LEName->setText(_aName);
1614       LEName->setReadOnly(true);
1615
1616       QString aDataFile = aBoundary->GetDataFile();
1617       LEFileName->setText(aDataFile);
1618       LEFileName->setReadOnly(1);
1619       PushFichier->setVisible(0);
1620 //
1621       adjustSize();
1622 }
1623 // ------------------------------
1624 bool SMESH_EditBoundaryDi::PushOnApply()
1625 // ------------------------------
1626 {
1627      return true;
1628 }
1629 // ------------------------------------------------------------------------
1630 void SMESH_EditBoundaryDi::SetFiltrage()
1631 // // ------------------------------------------------------------------------
1632 {
1633   if (!CBGroupe->isChecked()) return;
1634   SMESHHOMARD::HOMARD_Cas_var monCas = myHomardGen->GetCase();
1635   SMESHHOMARD::ListGroupType_var _listeGroupesCas = monCas->GetGroups();
1636
1637   SMESH_EditListGroup *aDlg = new SMESH_EditListGroup
1638     (this, true, SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen),
1639      "Case_1", _listeGroupesBoundary);
1640   aDlg->show();
1641 }