]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESHGUI/SMESHGUI_HomardBoundaryDlg.cxx
Salome HOME
Adding tests for netgen_runner and parallel compute
[modules/smesh.git] / 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 }