Salome HOME
#24666 [CEA][Windows] BLSURPLUGIN compilation issue
[modules/smesh.git] / src / StdMeshersGUI / StdMeshersGUI_CartesianParamCreator.cxx
1 // Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 // File   : StdMeshersGUI_CartesianParamCreator.cxx
23 // Author : Open CASCADE S.A.S.
24
25 // SMESH includes
26 #include "StdMeshersGUI_CartesianParamCreator.h"
27
28 #include "SMESHGUI.h"
29 #include "SMESHGUI_Utils.h"
30 #include "SMESHGUI_VTKUtils.h"
31 #include "SMESHGUI_HypothesesUtils.h"
32 #include "SMESHGUI_SpinBox.h"
33 #include "SMESHGUI_MeshEditPreview.h"
34
35 // IDL includes
36 #include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
37
38 // SALOME GUI includes
39 #include <LightApp_SelectionMgr.h>
40 #include <QtxComboBox.h>
41 #include <SALOME_InteractiveObject.hxx>
42 #include <SALOME_ListIO.hxx>
43 #include <SUIT_ResourceMgr.h>
44 #include <SalomeApp_IntSpinBox.h>
45 #include <SalomeApp_Tools.h>
46
47 #include <GEOMBase.h>
48
49 #include <BRepBndLib.hxx>
50 #include <Bnd_Box.hxx>
51 #include <TopoDS_Iterator.hxx>
52 #include <TopoDS_Shape.hxx>
53 #include <gp_Pnt.hxx>
54
55 // Qt includes
56 #include <QAbstractItemModel>
57 #include <QApplication>
58 #include <QButtonGroup>
59 #include <QCheckBox>
60 #include <QFontMetrics>
61 #include <QGridLayout>
62 #include <QGroupBox>
63 #include <QHBoxLayout>
64 #include <QLabel>
65 #include <QLineEdit>
66 #include <QListWidget>
67 #include <QModelIndex>
68 #include <QPushButton>
69 #include <QRadioButton>
70 #include <QString>
71 #include <QStyleOptionViewItem>
72 #include <QTabWidget>
73 #include <QTreeWidget>
74 #include <QTreeWidgetItem>
75 #include <QVBoxLayout>
76
77 #define SPACING 6
78 #define MARGIN  11
79
80 namespace StdMeshersGUI
81 {
82   enum { COORD_BUT = 0, SPACING_BUT };
83
84   //================================================================================
85   /*!
86    * \brief get spacing definition from a tree item
87    */
88   //================================================================================
89
90   void getFromItem(QTreeWidgetItem * item, double& t0, double& t1, QString& fun )
91   {
92     if ( item )
93     {
94       t0 = item->text( 0 ).split(' ')[0].toDouble();
95       t1 = item->data( 0, Qt::UserRole ).toDouble();
96       fun = item->text( 1 );
97     }
98   }
99
100   //================================================================================
101   /*!
102    * \brief set spacing definition to a tree item
103    */
104   //================================================================================
105
106   QTreeWidgetItem* setToItem(double t0, double t1, const QString& fun, QTreeWidgetItem * item)
107   {
108     if ( !item ) item = new QTreeWidgetItem;
109     item->setText( 0, QString( "%1 - %2" ).arg( t0 ).arg( t1 ));
110     item->setData( 0, Qt::UserRole, t1 );
111     item->setText( 1, fun );
112     item->setFlags( item->flags() | Qt::ItemIsEditable );
113     return item;
114   }
115
116   //================================================================================
117   /*!
118    * \brief Retrieves coordinate value from a list item
119    */
120   //================================================================================
121
122   double coordFromItem( QListWidgetItem * item )
123   {
124     return item ? item->data( Qt::UserRole ).toDouble() : 0;
125   }
126
127   //================================================================================
128   /*!
129    * \brief Sets coordinate value to a list item
130    */
131   //================================================================================
132
133   QListWidgetItem* coordToItem( double coord, QListWidgetItem * item )
134   {
135     if ( !item ) item = new QListWidgetItem;
136     item->setText( QString::number( coord ));
137     item->setData( Qt::UserRole, coord );
138     item->setFlags( item->flags() | Qt::ItemIsEditable );
139     return item;
140   }
141
142   //================================================================================
143   /*!
144    * \brief Constructor
145    * \param theParent - Parent widget for this tab
146    * 
147    * Makes tab's look and feel
148    */
149   //================================================================================
150
151   GridAxisTab::GridAxisTab( QWidget* theParent,const int axisIndex ):
152     QFrame( theParent ), myAxisIndex( axisIndex )
153   {
154     // 1) Grid definition mode
155     myModeGroup = new QButtonGroup( this );
156     QGroupBox* modeBox = new QGroupBox( tr( "GRID_DEF_MODE" ), this );
157     QHBoxLayout* modeLay = new QHBoxLayout( modeBox );
158     modeLay->setMargin( MARGIN );
159     modeLay->setSpacing( SPACING );
160
161     QRadioButton* coordModeBtn = new QRadioButton( tr( "SMESH_COORDINATES" ), modeBox );
162     QRadioButton* spacModeBtn  = new QRadioButton( tr( "SPACING" ), modeBox );
163
164     modeLay->addWidget( coordModeBtn );
165     modeLay->addWidget( spacModeBtn );
166     myModeGroup->addButton( coordModeBtn, COORD_BUT );
167     myModeGroup->addButton( spacModeBtn,  SPACING_BUT );
168
169     // 2) Buttons + Step
170     myInsertBtn = new QPushButton( tr("INSERT"), this);
171     myDeleteBtn = new QPushButton( tr("SMESH_BUT_DELETE"), this);
172
173     myStepLabel = new QLabel( tr("COORD_STEP"));
174     myStepSpin  = new SMESHGUI_SpinBox( this );
175     myStepSpin->setAcceptNames( false ); // No Notebook variables allowed
176     myStepSpin->RangeStepAndValidator();
177     myStepSpin->SetStep( 1. );
178     myStepSpin->SetValue( myStep = 1. );
179
180     // 3) Coordinates/Spacing group
181     QFrame*    csFrame = new QFrame( this );
182     QVBoxLayout* scLay = new QVBoxLayout( csFrame );
183     scLay->setMargin( 0 );
184     scLay->setSpacing( SPACING );
185
186     // 3.1) Spacing
187     mySpacingTreeWdg = new QTreeWidget( csFrame );
188     mySpacingTreeWdg->setColumnCount(2);
189     mySpacingTreeWdg->setHeaderLabels( QStringList() << tr( "SMESH_RANGE" ) << QString( "f(t)" ));
190     mySpacingTreeWdg->setColumnWidth( 1, 40 );
191     mySpacingTreeWdg->setColumnWidth( 2, 30 );
192     mySpacingTreeWdg->setItemDelegate( new LineDelegate( mySpacingTreeWdg ));
193     scLay->addWidget( mySpacingTreeWdg );
194
195     // 3.2) Coordinates
196     myCoordList = new QListWidget( csFrame );
197     myCoordList->setItemDelegate( new LineDelegate( myCoordList ));
198     scLay->addWidget( myCoordList );
199
200     // layouting
201
202     QGridLayout* axisTabLayout = new QGridLayout( this );
203     axisTabLayout->setMargin( MARGIN );
204     axisTabLayout->setSpacing( SPACING );
205
206     axisTabLayout->addWidget( modeBox    , 0, 0, 1, 3 );
207     axisTabLayout->addWidget( myInsertBtn, 1, 0, 1, 2 );
208     axisTabLayout->addWidget( myDeleteBtn, 2, 0, 1, 2 );
209     axisTabLayout->addWidget( myStepLabel, 3, 0 );
210     axisTabLayout->addWidget( myStepSpin , 3, 1 );
211     axisTabLayout->addWidget( csFrame    , 1, 2, 4, 1 );
212
213     axisTabLayout->setRowStretch( 4, 1 );
214
215     // signals
216     connect( myInsertBtn,      SIGNAL( clicked() ),             SLOT( onInsert() ));
217     connect( myDeleteBtn,      SIGNAL( clicked() ),             SLOT( onDelete() ));
218     connect( myModeGroup,      SIGNAL( buttonClicked ( int )),  SLOT( onMode(int)));
219     connect( myModeGroup,      SIGNAL( buttonClicked ( int )),  SIGNAL( gridModeChanged(int)));
220     connect( mySpacingTreeWdg, SIGNAL( itemSelectionChanged()), SLOT( updateButtons() ));
221     connect( myCoordList,      SIGNAL( itemSelectionChanged()), SLOT( updateButtons() ));
222     connect( myStepSpin,       SIGNAL( valueChanged(double)),   SLOT( onStepChange() ));
223   }
224
225   //================================================================================
226   /*!
227    * \brief SLOT onInsert
228    */
229   //================================================================================
230
231   void GridAxisTab::onInsert()
232   {
233     if ( isGridBySpacing() )
234     {
235       QTreeWidgetItem * item = mySpacingTreeWdg->currentItem();
236       if ( !item ) item = mySpacingTreeWdg->topLevelItem( 0 );
237       int i = mySpacingTreeWdg->indexOfTopLevelItem( item );
238
239       double t0, t1; QString fun;
240       getFromItem( item, t0, t1, fun );
241       double t = 0.5 * ( t0 + t1 );
242       setToItem( t0, t, fun, item );
243
244       item = setToItem( t, t1, fun );
245       if ( i == mySpacingTreeWdg->topLevelItemCount()-1 )
246         mySpacingTreeWdg->addTopLevelItem( item );
247       else
248         mySpacingTreeWdg->insertTopLevelItem( i+1, item );
249       mySpacingTreeWdg->setCurrentItem( item );
250     }
251     else
252     {
253       if ( myCoordList->count() == 0 )
254       {
255         myCoordList->addItem( coordToItem( 0 ));
256       }
257       else
258       {
259         double coord = coordFromItem( myCoordList->currentItem() ) + myStep;
260         int i = myCoordList->currentRow();
261         while ( i > 0 && coordFromItem( myCoordList->item( i-1 )) > coord )
262           --i;
263         while ( i < myCoordList->count() && coordFromItem( myCoordList->item( i )) < coord )
264           ++i;
265         const double tol = 1e-6;
266         const bool isSame = 
267           ( i < myCoordList->count() && coordFromItem( myCoordList->item( i )) - coord < tol ) ||
268           ( i > 0 && coord - coordFromItem( myCoordList->item( i-1 )) < tol );
269         if ( !isSame )
270           myCoordList->insertItem( i, coordToItem( coord ));
271         else if ( myStep < 0 )
272           --i;
273         myCoordList->setCurrentRow( i );
274       }
275     }
276     updateButtons();
277   }
278
279   //================================================================================
280   /*!
281    * \brief SLOT onDelete
282    */
283   //================================================================================
284
285   void GridAxisTab::onDelete()
286   {
287     if ( isGridBySpacing() )
288     {
289       QList<QTreeWidgetItem *> selItems = mySpacingTreeWdg->selectedItems();
290       QTreeWidgetItem * item;
291       foreach ( item, selItems )
292       {
293         int i = mySpacingTreeWdg->indexOfTopLevelItem( item );
294         if ( i == 0 ) continue; 
295         QTreeWidgetItem* prevItem = mySpacingTreeWdg->topLevelItem( i-1 );
296
297         double t0, t1, t2; QString fun;
298         getFromItem( item, t1, t2, fun );
299         getFromItem( prevItem, t0, t1, fun );
300         delete item;
301
302         setToItem( t0, t2, fun, prevItem );
303       }
304     }
305     else
306     {
307       if ( myCoordList->count() > 2 )
308         if ( QListWidgetItem * item = myCoordList->currentItem() )
309           delete item;
310     }
311     updateButtons();
312   }
313
314   //================================================================================
315   /*!
316    * \brief SLOT onMode
317    */
318   //================================================================================
319
320   void GridAxisTab::onMode(int isSpacing)
321   {
322     mySpacingTreeWdg->setVisible( isSpacing );
323     myCoordList->setVisible( !isSpacing );
324     myStepSpin->setVisible( !isSpacing );
325     myStepLabel->setVisible( !isSpacing );
326     if ( isSpacing )
327     {
328       if ( mySpacingTreeWdg->topLevelItemCount() == 0 )
329       {
330         QString spacing( "1" );
331         if ( myCoordList->count() > 1 )
332         {
333           double c1 = coordFromItem( myCoordList->item( 1 ));
334           double c0 = coordFromItem( myCoordList->item( 0 ));
335           spacing = QString::number( c1 - c0 );
336         }
337         mySpacingTreeWdg->addTopLevelItem( setToItem( 0., 1., spacing ) );
338       }
339       //myCoordList->clear();
340     }
341     else
342     {
343       //mySpacingTreeWdg->clear();
344       if ( myCoordList->count() == 0 )
345         myCoordList->addItem( coordToItem( 0 ));
346     }
347     updateButtons();
348   }
349
350   //================================================================================
351   /*!
352    * \brief SLOT onStepChange
353    */
354   //================================================================================
355
356   void GridAxisTab::onStepChange()
357   {
358     if ( fabs( myStepSpin->GetValue() ) < 1e-100 )
359     {
360       double delta = myStepSpin->singleStep() * ( myStep > myStepSpin->GetValue() ? -1 : +1 );
361       myStepSpin->SetValue( myStepSpin->GetValue() + delta );
362     }
363     myStep = myStepSpin->GetValue();
364   }
365
366   //================================================================================
367   /*!
368    * \brief Enables/disables buttons
369    */
370   //================================================================================
371
372   void GridAxisTab::updateButtons()
373   {
374     bool insertEnable = false, deleteEnable = false;
375     if ( isGridBySpacing() )
376     {
377       insertEnable = true;
378       const int nbSelected = mySpacingTreeWdg->selectedItems().count();
379       if ( nbSelected > 0 )
380       {
381         // we delete a current range by uniting it with the previous
382         int i = mySpacingTreeWdg->indexOfTopLevelItem(  mySpacingTreeWdg->currentItem() );
383         deleteEnable = ( i > 0 );
384       }
385     }
386     else
387     {
388       const int nbSelected = myCoordList->selectedItems().count();
389       insertEnable = ( nbSelected || myCoordList->count() < 2 );
390       deleteEnable = ( nbSelected && myCoordList->count() > 2 );
391     }
392     myInsertBtn->setEnabled( insertEnable );
393     myDeleteBtn->setEnabled( deleteEnable );
394   }
395
396   //================================================================================
397   /*!
398    * \brief Inserts coordinates into myCoordList
399    */
400   //================================================================================
401
402   void GridAxisTab::setCoordinates( SMESH::double_array_var coords )
403   {
404     myCoordList->clear();
405     for ( size_t i = 0; i < coords->length(); ++i )
406       myCoordList->addItem( coordToItem( coords[i] ));
407
408     myModeGroup->button( COORD_BUT )->setChecked( true );
409     onMode( COORD_BUT );
410   }
411
412   //================================================================================
413   /*!
414    * \brief Sets spacing got from hypothesis
415    */
416   //================================================================================
417
418   void GridAxisTab::setSpacing( SMESH::string_array_var funs, SMESH::double_array_var points )
419   {
420     mySpacingTreeWdg->clear();
421     if ( funs->length() == points->length() - 1 )
422     {
423       for ( size_t i = 1; i < points->length(); ++i )
424         mySpacingTreeWdg->addTopLevelItem
425           ( setToItem( points[i-1], points[i], (const char*) funs[i-1] ));
426     }
427     myModeGroup->button( SPACING_BUT )->setChecked( true );
428     onMode( SPACING_BUT );
429   }
430
431   //================================================================================
432   /*!
433    * \brief Checks grid definition mode
434    */
435   //================================================================================
436
437   bool GridAxisTab::isGridBySpacing() const
438   {
439     return ( myModeGroup->checkedId() == SPACING_BUT );
440   }
441
442   //================================================================================
443   /*!
444    * \brief Returns coordinates to set to a hypothesis
445    */
446   //================================================================================
447
448   SMESH::double_array* GridAxisTab::getCoordinates()
449   {
450     SMESH::double_array_var coords = new SMESH::double_array;
451     coords->length( myCoordList->count() );
452     for ( size_t i = 0; i < coords->length(); ++i )
453       coords[i] = coordFromItem( myCoordList->item( i ) );
454
455     return coords._retn();
456   }
457
458   //================================================================================
459   /*!
460    * \brief Returns spacing to set to a hypothesis
461    */
462   //================================================================================
463
464   void GridAxisTab::getSpacing(SMESH::string_array_out funs,
465                                SMESH::double_array_out points) const
466   {
467     funs =  new SMESH::string_array();
468     points = new SMESH::double_array();
469     funs->length( mySpacingTreeWdg->topLevelItemCount() );
470     points->length( mySpacingTreeWdg->topLevelItemCount() + 1 );
471     double t0, t1; QString fun;
472     for ( size_t i = 0; i < funs->length(); ++i )
473     {
474       QTreeWidgetItem* item = mySpacingTreeWdg->topLevelItem( i );
475       getFromItem( item, t0, t1, fun );
476       points[i] = t0;
477       funs[i] = fun.toLatin1().constData();
478     }
479     points[ points->length()-1 ] = 1.0;
480   }
481
482
483   //================================================================================
484   /*!
485    * \brief Verifies parameters
486    */
487   //================================================================================
488
489   bool GridAxisTab::checkParams(QString& msg, SMESH::SMESH_Hypothesis_var& hyp) const
490   {
491     if ( isGridBySpacing() )
492     {
493       if ( mySpacingTreeWdg->topLevelItemCount() == 0 )
494         return false; // how could it be?
495       StdMeshers::StdMeshers_CartesianParameters3D_var h =
496         StdMeshers::StdMeshers_CartesianParameters3D::_narrow( hyp );
497       SMESH::string_array_var funs;
498       SMESH::double_array_var points;
499       getSpacing( funs.out(), points.out() );
500       try {
501         const char* axisName[3] = { "X", "Y", "Z" };
502         SMESH::double_array_var coords =
503           h->ComputeCoordinates(0.,1., funs, points, axisName[ myAxisIndex ]);
504       }
505       catch ( const SALOME::SALOME_Exception& ex ) {
506         msg = (const char*) ex.details.text;
507         return false;
508       }
509     }
510     else
511     {
512       return myCoordList->count() > 1;
513     }
514     return true;
515   }
516
517   //================================================================================
518   /*!
519    * \brief LineDelegate constructor
520    */
521   //================================================================================
522
523   LineDelegate::LineDelegate( QWidget* parent ):
524     QItemDelegate( parent ),
525     mySpacingTreeWdg( qobject_cast<QTreeWidget*>( parent )),
526     myCoordList( qobject_cast<QListWidget*>( parent ))
527   {
528   }
529
530   //================================================================================
531   /*!
532    * \brief Creates an editor depending on a current item
533    */
534   //================================================================================
535
536   QWidget* LineDelegate::createEditor( QWidget*                    parent,
537                                        const QStyleOptionViewItem& /*opt*/,
538                                        const QModelIndex&          index) const
539   {
540     QWidget* w = 0;
541     if ( mySpacingTreeWdg )
542     {
543       if ( index.column() == 0 &&
544            index.row() != mySpacingTreeWdg->topLevelItemCount()-1 )
545       {
546         SMESHGUI_SpinBox* sb = new SMESHGUI_SpinBox( parent );
547         sb->setAcceptNames( false ); // No Notebook variables allowed
548         sb->setFrame( false );
549         w = sb;
550       }
551       if ( index.column() == 1 ) {
552         w = new QLineEdit( parent );
553       }
554     }
555     else
556     {
557       SMESHGUI_SpinBox* sb = new SMESHGUI_SpinBox( parent );
558       sb->setAcceptNames( false ); // No Notebook variables allowed
559       sb->setFrame( false );
560       const double tol = 1e-5;
561       double from = index.row() ? coordFromItem( myCoordList->item( index.row()-1 ))+tol : -1e+6;
562       double to = index.row() == myCoordList->count()-1 ? 1e+6 : coordFromItem( myCoordList->item( index.row()+1 ))-tol;
563       sb->RangeStepAndValidator( from, to, 0.01 );
564       w = sb;
565     }
566     return w;
567   }
568
569   //================================================================================
570   /*!
571    * \brief Limit value range in the spin of a neighbor range
572    */
573   //================================================================================
574
575   void LineDelegate::setEditorData ( QWidget * editor, const QModelIndex & index ) const
576   {
577     if ( mySpacingTreeWdg && index.column() == 0 )
578     {
579       double t0, t1, t2=1.0; QString fun;
580       QTreeWidgetItem* item = mySpacingTreeWdg->topLevelItem( index.row() );
581       getFromItem( item, t0, t1, fun );
582       if ( index.row() != mySpacingTreeWdg->topLevelItemCount()-1 )
583       {
584         item = mySpacingTreeWdg->topLevelItem( index.row()+1 );
585         getFromItem( item, t1, t2, fun );
586       }
587       const double tol = 1e-3;
588       SMESHGUI_SpinBox* sb = qobject_cast<SMESHGUI_SpinBox*>( editor );
589       sb->RangeStepAndValidator( t0 + tol, t2 - tol, 0.01 );
590       sb->SetValue( t1 );
591     }
592     else
593     {
594       QItemDelegate::setEditorData( editor, index );
595     }
596   }
597
598   //================================================================================
599   /*!
600    * \brief
601    */
602   //================================================================================
603
604   void LineDelegate::setModelData( QWidget*            editor,
605                                    QAbstractItemModel* model,
606                                    const QModelIndex&  index ) const
607   {
608     if ( mySpacingTreeWdg )
609     {
610       if ( index.column() == 0 )
611       {
612         if ( index.row() != mySpacingTreeWdg->topLevelItemCount()-1 )
613         {
614           SMESHGUI_SpinBox* sb = qobject_cast<SMESHGUI_SpinBox*>( editor );
615           double t0, t1, t = sb->GetValue(); QString fun;
616
617           QTreeWidgetItem* item = mySpacingTreeWdg->topLevelItem( index.row() );
618           getFromItem( item, t0, t1, fun );
619           setToItem( t0, t, fun, item );
620
621           item = mySpacingTreeWdg->topLevelItem( index.row() + 1 );
622           getFromItem( item, t0, t1, fun );
623           setToItem( t, t1, fun, item );
624         }
625       }
626       else if ( !qobject_cast<QLineEdit*>(editor)->text().trimmed().isEmpty() )
627       {
628         QItemDelegate::setModelData( editor, model, index );
629       }
630     }
631     else
632     {
633       SMESHGUI_SpinBox* sb = qobject_cast<SMESHGUI_SpinBox*>( editor );
634       coordToItem( sb->GetValue(), myCoordList->item( index.row() ));
635     }
636   }
637
638 } // namespace StdMeshersGUI
639
640 namespace
641 {
642   const double theAngTol = M_PI / 180.;
643
644   //================================================================================
645   /*!
646    * \brief Set variables to groups of spin boxes
647    */
648   //================================================================================
649
650   void setText( const QString& vars, SMESHGUI_SpinBox** spins )
651   {
652     QStringList varList = vars.split( ':' );
653     for ( int i = 0; i < 3 && i < varList.count(); ++i )
654       if ( !varList[i].isEmpty() )
655         spins[i]->setText( varList[i] );
656   }
657   
658   //================================================================================
659   /*!
660    * \brief Computes more 2 axes by one
661    *  \param [in] iOk - index of a given axis
662    *  \param [in,out] dirs - directions of 3 axes
663    */
664   //================================================================================
665
666   void get3Dirs( int iOk, gp_XYZ dirs[3] )
667   {
668     dirs[ ( iOk+1 ) % 3 ] = dirs[ iOk ];
669
670     if ( Abs( dirs[ iOk ].Y() ) < 1e-100 &&
671          Abs( dirs[ iOk ].Z() ) < 1e-100 )
672       // dirs[ iOk ] || OX
673       dirs[ ( iOk+1 ) % 3 ].SetY( dirs[ iOk ].Y() + 1. );
674     else
675       dirs[ ( iOk+1 ) % 3 ].SetX( dirs[ iOk ].X() + 1. );
676
677     dirs[( iOk+2 ) % 3] = dirs[ iOk ] ^ dirs[ ( iOk+1 ) % 3 ];
678     dirs[( iOk+1 ) % 3] = dirs[ ( iOk+2 ) % 3 ] ^ dirs[ iOk ];
679   }
680
681   //================================================================================
682   /*!
683    * \brief Returns a minimal width of a SpinBox depending on a precision type
684    */
685   //================================================================================
686
687   int getMinWidth( const char* precisionType )
688   {
689     int nb = SMESHGUI::resourceMgr()->integerValue( "SMESH", precisionType, -3 );
690     QString s;
691     s.fill('0', qAbs(nb)+7 );
692     QLineEdit le;
693     QFontMetrics metrics( le.font() );
694     return metrics.width( s );
695   }
696 }
697
698 //================================================================================
699 /*!
700  * \brief StdMeshersGUI_CartesianParamCreator constructor
701  */
702 //================================================================================
703
704 StdMeshersGUI_CartesianParamCreator::StdMeshersGUI_CartesianParamCreator(const QString& aHypType)
705   : StdMeshersGUI_StdHypothesisCreator( aHypType ),
706     myThreshold( 0 )
707 {
708   myAxisTabs[0] = 0;
709   myAxisTabs[1] = 0;
710   myAxisTabs[2] = 0;
711
712   myAxesPreview = new SMESHGUI_MeshEditPreview( SMESH::GetViewWindow( SMESHGUI::GetSMESHGUI() ));
713   myAxesPreview->SetArrowShapeAndNb( /*nbArrows=*/3,
714                                      /*headLength=*/0.1,
715                                      /*headRadius=*/0.01,
716                                      /*start=*/0.,
717                                      /*labels=*/"XYZ");
718
719   myDirTic[0] = myDirTic[1] = myDirTic[2] = 0;
720 }
721
722 //================================================================================
723 /*!
724  * \brief StdMeshersGUI_CartesianParamCreator destructor
725  */
726 //================================================================================
727
728 StdMeshersGUI_CartesianParamCreator::~StdMeshersGUI_CartesianParamCreator()
729 {
730   if ( myAxisTabs[0] ) delete myAxisTabs[0];
731   if ( myAxisTabs[1] ) delete myAxisTabs[1];
732   if ( myAxisTabs[2] ) delete myAxisTabs[2];
733   myAxisTabs[0] = 0;
734   myAxisTabs[1] = 0;
735   myAxisTabs[2] = 0;
736
737   delete myAxesPreview;
738 }
739
740 //================================================================================
741 /*!
742  * \brief Validate parameters
743  */
744 //================================================================================
745
746 bool StdMeshersGUI_CartesianParamCreator::checkParams( QString& msg ) const
747 {
748   if( !SMESHGUI_GenericHypothesisCreator::checkParams( msg ) )
749     return false;
750
751   if ( myName && myName->text().trimmed().isEmpty() )
752   {
753     msg = tr("SMESH_WRN_EMPTY_NAME");
754     return false;
755   }
756   if ( ! myThreshold->isValid( msg, true ))
757     return false;
758
759   SMESH::SMESH_Hypothesis_var hyp = hypothesis();
760   if ( !myAxisTabs[0]->checkParams( msg, hyp )) return false;
761   if ( !myAxisTabs[1]->checkParams( msg, hyp )) return false;
762   if ( !myAxisTabs[2]->checkParams( msg, hyp )) return false;
763
764   StdMeshersGUI_CartesianParamCreator* me = (StdMeshersGUI_CartesianParamCreator*) this;
765   if ( !me->updateAxesPreview() )
766   {
767     msg = tr("INVALID_AXES_DIR");
768     return false;
769   }
770
771   return true;
772 }
773
774 //================================================================================
775 /*!
776  * \brief Create widgets
777  */
778 //================================================================================
779
780 QFrame* StdMeshersGUI_CartesianParamCreator::buildFrame()
781 {
782   QFrame* fr = new QFrame();
783   //fr->setMinimumWidth(460);
784
785   QVBoxLayout* lay = new QVBoxLayout( fr );
786   lay->setMargin( 0 );
787   lay->setSpacing( SPACING );
788
789   QGroupBox* GroupC1 = new QGroupBox( tr( "SMESH_ARGUMENTS" ), fr );
790   lay->addWidget( GroupC1 );
791
792   StdMeshers::StdMeshers_NumberOfSegments_var h =
793     StdMeshers::StdMeshers_NumberOfSegments::_narrow( hypothesis() );
794
795   QGridLayout* argGroupLayout = new QGridLayout( GroupC1 );
796   argGroupLayout->setSpacing( SPACING );
797   argGroupLayout->setMargin( MARGIN );
798   argGroupLayout->setColumnStretch( 0, 0 );
799   argGroupLayout->setColumnStretch( 1, 1 );
800
801   int row = 0;
802   // 0)  name
803   myName = 0;
804   if( isCreation() )
805   {
806     myName = new QLineEdit( GroupC1 );
807     argGroupLayout->addWidget( new QLabel( tr( "SMESH_NAME" ), GroupC1 ), row, 0 );
808     argGroupLayout->addWidget( myName, row, 1 );
809     row++;
810   }
811
812   // 1)  threshold
813   argGroupLayout->addWidget( new QLabel( tr( "THRESHOLD" ), GroupC1 ), row, 0 );
814   myThreshold = new SMESHGUI_SpinBox( GroupC1 );
815   myThreshold->setAcceptNames( false ); // No Notebook variables allowed
816   myThreshold->RangeStepAndValidator( 1.00001, 1e+10, 1., "length_precision" );
817   argGroupLayout->addWidget( myThreshold, row, 1 );
818   row++;
819   
820   // 2)  "Implement edges"
821   myAddEdges = new QCheckBox( tr("ADD_EDGES"), GroupC1 );
822   argGroupLayout->addWidget( myAddEdges, row, 0, 1, 2 );
823   row++;
824   myCreateFaces = new QCheckBox( tr("CREATE_FACES"), GroupC1 );
825   argGroupLayout->addWidget( myCreateFaces, row, 0, 1, 2 );
826   row++;
827   myConsiderInternalFaces = new QCheckBox( tr("CONSIDER_INTERNAL_FACES"), GroupC1 );
828   argGroupLayout->addWidget( myConsiderInternalFaces, row, 0, 1, 2 );
829   row++;
830   myUseThresholdForInternalFaces = new QCheckBox( tr("USE_THRESHOLD_FOR_INTERNAL_FACES"), GroupC1 );
831   argGroupLayout->addWidget( myUseThresholdForInternalFaces, row, 0, 1, 2 );
832   row++;
833
834   // 3)  Grid definition
835   QTabWidget* tabWdg = new QTabWidget( fr );
836   myAxisTabs[ 0 ] = new StdMeshersGUI::GridAxisTab( tabWdg, 0 );
837   myAxisTabs[ 1 ] = new StdMeshersGUI::GridAxisTab( tabWdg, 1 );
838   myAxisTabs[ 2 ] = new StdMeshersGUI::GridAxisTab( tabWdg, 2 );
839   tabWdg->addTab( myAxisTabs[ 0 ], tr( "AXIS_X" ) );
840   tabWdg->addTab( myAxisTabs[ 1 ], tr( "AXIS_Y" ) );
841   tabWdg->addTab( myAxisTabs[ 2 ], tr( "AXIS_Z" ) );
842   argGroupLayout->addWidget( tabWdg, row, 0, 1, 2 );
843   row++;
844
845   QPixmap aPix = SMESHGUI::resourceMgr()->loadPixmap("SMESH", tr("ICON_SELECT"));
846
847   // 4) Fixed point
848   myFixedPointGrp = new QGroupBox( tr("FIXED_POINT"), fr );
849   myFixedPointGrp->setCheckable( true );
850   //QPushButton* pointBtn = new QPushButton( QIcon(aPix), "", myFixedPointGrp );
851   QLabel* pXLbl = new QLabel( tr("SMESH_X"), myFixedPointGrp );
852   QLabel* pYLbl = new QLabel( tr("SMESH_Y"), myFixedPointGrp );
853   QLabel* pZLbl = new QLabel( tr("SMESH_Z"), myFixedPointGrp );
854   for ( int i = 0; i < 3; ++i )
855   {
856     myPointSpin[i] = new SMESHGUI_SpinBox( myFixedPointGrp );
857     myPointSpin[i]->RangeStepAndValidator( -1e20, 1e20, 10 );
858     myPointSpin[i]->SetValue( 0. );
859   }
860   QHBoxLayout* aFixedPointLay = new QHBoxLayout( myFixedPointGrp );
861   aFixedPointLay->addWidget( pXLbl, 0, Qt::AlignRight );
862   aFixedPointLay->addWidget( myPointSpin[0], 1 );
863   aFixedPointLay->addWidget( pYLbl, 0, Qt::AlignRight );
864   aFixedPointLay->addWidget( myPointSpin[1], 1 );
865   aFixedPointLay->addWidget( pZLbl, 0, Qt::AlignRight );
866   aFixedPointLay->addWidget( myPointSpin[2], 1 );
867   argGroupLayout->addWidget( myFixedPointGrp, row, 0, 1, 2 );
868   row++;
869
870   // 5) Axes direction
871   QGroupBox* axesDirGrp = new QGroupBox( tr("AXES_DIRECTION"), fr );
872   QGridLayout* axisDirLay = new QGridLayout( axesDirGrp );
873   axisDirLay->setSpacing( SPACING );
874   axisDirLay->setMargin( MARGIN );
875   axisDirLay->setColumnStretch( 0, 2 );
876   // is orthogonal
877   myOrthogonalChk = new QCheckBox( tr("ORTHOGONAL_AXES"), axesDirGrp );
878   axisDirLay->addWidget( myOrthogonalChk, 0, 0, 1, 7 );
879   // axes
880   QLabel* axisLbl[3];
881   axisLbl[0] = new QLabel( tr( "AXIS_X"), axesDirGrp );
882   axisLbl[1] = new QLabel( tr( "AXIS_Y"), axesDirGrp );
883   axisLbl[2] = new QLabel( tr( "AXIS_Z"), axesDirGrp );
884   QLabel* dLbl[3];
885   myAxisBtnGrp = new QButtonGroup( axesDirGrp );
886   // get spin width
887   const char * const precisionType = "len_tol_precision";
888   int minWidth = getMinWidth( precisionType );
889   for ( int i = 0; i < 3; ++i )
890   {
891     QPushButton* axisBtn = new QPushButton( QIcon(aPix), "", axesDirGrp );
892     axisBtn->setCheckable( true );
893     myAxisBtnGrp->addButton( axisBtn, i );
894     myXDirSpin[i] = new SMESHGUI_SpinBox( axesDirGrp );
895     myYDirSpin[i] = new SMESHGUI_SpinBox( axesDirGrp );
896     myZDirSpin[i] = new SMESHGUI_SpinBox( axesDirGrp );
897     myXDirSpin[i]->RangeStepAndValidator( -1, 1, 0.1, precisionType );
898     myYDirSpin[i]->RangeStepAndValidator( -1, 1, 0.1, precisionType );
899     myZDirSpin[i]->RangeStepAndValidator( -1, 1, 0.1, precisionType );
900     myXDirSpin[i]->setMinimumWidth( minWidth );
901     myYDirSpin[i]->setMinimumWidth( minWidth );
902     myZDirSpin[i]->setMinimumWidth( minWidth );
903     dLbl[0] = new QLabel( tr("SMESH_DX"), axesDirGrp );
904     dLbl[1] = new QLabel( tr("SMESH_DY"), axesDirGrp );
905     dLbl[2] = new QLabel( tr("SMESH_DZ"), axesDirGrp );
906     axisDirLay->addWidget( axisLbl[i],    i+1, 0 );
907     axisDirLay->addWidget( axisBtn,       i+1, 1 );
908     axisDirLay->addWidget( dLbl[0],       i+1, 2 );
909     axisDirLay->addWidget( dLbl[1],       i+1, 4 );
910     axisDirLay->addWidget( dLbl[2],       i+1, 6 );
911     axisDirLay->addWidget( myXDirSpin[i], 1, 3+i*2 );
912     axisDirLay->addWidget( myYDirSpin[i], 2, 3+i*2 );
913     axisDirLay->addWidget( myZDirSpin[i], 3, 3+i*2 );
914   }
915   axisDirLay->setColumnStretch( 3, 10 );
916   axisDirLay->setColumnStretch( 5, 10 );
917   axisDirLay->setColumnStretch( 7, 10 );
918
919   // set optimal axes
920   QPushButton* optimBtn = new QPushButton( tr("OPTIMAL_AXES"), axesDirGrp );
921   QPushButton* resetBtn = new QPushButton( tr("RESET_AXES"), axesDirGrp );
922   axisDirLay->addWidget( optimBtn, 4, 0, 1, 4 );
923   axisDirLay->addWidget( resetBtn, 4, 4, 1, 4 );
924
925   argGroupLayout->addWidget( axesDirGrp, row, 0, 1, 2 );
926   row++;
927
928   // Signals
929
930   LightApp_SelectionMgr* selMgr = SMESH::GetSelectionMgr( SMESHGUI::GetSMESHGUI() );
931
932   connect( selMgr,          SIGNAL( currentSelectionChanged()), SLOT( onSelectionChange()));
933   connect( myOrthogonalChk, SIGNAL( toggled(bool)),             SLOT( onOrthogonalAxes(bool)));
934   connect( optimBtn,        SIGNAL( clicked(bool)),             SLOT( onOptimalAxes(bool)));
935   connect( resetBtn,        SIGNAL( clicked(bool)),             SLOT( onResetAxes(bool)));
936   connect( myConsiderInternalFaces,      SIGNAL( toggled(bool)),
937            myUseThresholdForInternalFaces, SLOT( setEnabled(bool)));
938   for ( int i = 0; i < 3; ++i )
939   {
940     connect( myXDirSpin[i], SIGNAL(valueChanged   (const QString&)),
941              this,          SLOT  (onAxisDirChange(const QString&)) );
942     connect( myYDirSpin[i], SIGNAL(valueChanged   (const QString&)),
943              this,          SLOT  (onAxisDirChange(const QString&)) );
944     connect( myZDirSpin[i], SIGNAL(valueChanged   (const QString&)),
945              this,          SLOT  (onAxisDirChange(const QString&)) );
946     connect( myAxisTabs[i], SIGNAL(gridModeChanged(int)),
947              this,          SLOT  (onGridModeChanged(int)));
948   }
949
950   // Show axes
951   myAxesLen = 120; // default trihedron size is 100
952   myOrigin[0] = myOrigin[1] = myOrigin[2] = 0.;
953   TopoDS_Shape shape;
954   QString shapeEntry = getMainShapeEntry();
955   if ( !shapeEntry.isEmpty() )
956   {
957     // find origin
958     GEOM::GEOM_Object_var geomObj = SMESH::EntryToInterface<GEOM::GEOM_Object>( shapeEntry );
959     if ( GEOMBase::GetShape( geomObj, shape ) && !shape.IsNull())
960     {
961       Bnd_Box box;
962       BRepBndLib::Add( shape, box );
963       double max[3];
964       if ( !box.IsVoid() )
965       {
966         box.Get( myOrigin[0], myOrigin[1], myOrigin[2], max[0], max[1], max[2] );
967         gp_Pnt o( myOrigin[0], myOrigin[1], myOrigin[2] );
968         gp_Pnt x( max[0], max[1], max[2] );
969         myAxesLen = o.Distance( x );
970
971         double step = 1e20;
972         while ( step > myAxesLen / 5 )
973           step /= 10;
974         myPointSpin[0]->SetStep( step );
975         myPointSpin[1]->SetStep( step );
976         myPointSpin[2]->SetStep( step );
977       }
978     }
979   }
980   myAxisBtnGrp->button(0)->setEnabled( !shape.IsNull() );
981   myAxisBtnGrp->button(1)->setEnabled( !shape.IsNull() );
982   myAxisBtnGrp->button(2)->setEnabled( !shape.IsNull() );
983   optimBtn->setEnabled( !shape.IsNull() );
984
985   updateAxesPreview();
986
987   return fr;
988 }
989
990 //================================================================================
991 /*!
992  * \brief Transfer parameters from hypothesis to widgets
993  */
994 //================================================================================
995
996 void StdMeshersGUI_CartesianParamCreator::retrieveParams() const
997 {
998   StdMeshers::StdMeshers_CartesianParameters3D_var h =
999     StdMeshers::StdMeshers_CartesianParameters3D::_narrow( initParamsHypothesis() );
1000
1001   if( myName )
1002     myName->setText( hypName() );
1003
1004   QString varName = getVariableName( "SetSizeThreshold" );
1005   if ( varName.isEmpty() )
1006     myThreshold->setValue( h->GetSizeThreshold() );
1007   else
1008     myThreshold->setText( varName );
1009
1010   myAddEdges->setChecked( h->GetToAddEdges() );
1011   myCreateFaces->setChecked( h->GetToCreateFaces() );
1012   myConsiderInternalFaces->setChecked( h->GetToConsiderInternalFaces() );
1013   myUseThresholdForInternalFaces->setChecked( h->GetToUseThresholdForInternalFaces() );
1014
1015   // grid definition
1016   for ( int ax = 0; ax < 3; ++ax )
1017   {
1018     if ( h->IsGridBySpacing( ax ))
1019     {
1020       SMESH::string_array_var funs;
1021       SMESH::double_array_var intPoints;
1022       h->GetGridSpacing( funs.out(), intPoints.out(), ax );
1023       myAxisTabs[ax]->setSpacing( funs, intPoints );
1024     }
1025     else
1026     {
1027       SMESH::double_array_var coords = h->GetGrid( ax );
1028       myAxisTabs[ax]->setCoordinates( coords );
1029     }
1030   }
1031
1032   // fixed point
1033   SMESH::PointStruct fp;
1034   StdMeshersGUI_CartesianParamCreator* me = (StdMeshersGUI_CartesianParamCreator*) this;
1035   if ( h->GetFixedPoint( fp ))
1036   {
1037     me->myPointSpin[0]->SetValue( fp.x );
1038     me->myPointSpin[1]->SetValue( fp.y );
1039     me->myPointSpin[2]->SetValue( fp.z );
1040     setText( getVariableName("GetFixedPoint"), &me->myPointSpin[0] );
1041     myFixedPointGrp->setChecked( true );
1042   }
1043   else
1044   {
1045     myFixedPointGrp->setChecked( false );
1046   }
1047
1048   // axes directions
1049   SMESHGUI_SpinBox** spins[3] = { &me->myXDirSpin[0], &me->myYDirSpin[0], &me->myZDirSpin[0] };
1050   SMESH::DirStruct axisDir[3];
1051   h->GetAxesDirs( axisDir[0],
1052                   axisDir[1],
1053                   axisDir[2]);
1054   QString vars = getVariableName("GetAxesDirs");
1055   for ( int i = 0; i < 3; ++i )
1056   {
1057     spins[i][0]->SetValue( axisDir[i].PS.x );
1058     spins[i][1]->SetValue( axisDir[i].PS.y );
1059     spins[i][2]->SetValue( axisDir[i].PS.z );
1060     setText( vars, spins[i] );
1061
1062     // cut off 3 used vars
1063     if ( !vars.isEmpty() )
1064     {
1065       int ind = -1;
1066       for ( int j = 0; j < 3; ++j )
1067         if (( ind = vars.indexOf(':', ind+1 )) < 0 )
1068           break;
1069       if ( ind < 0 )
1070         vars.clear();
1071       else
1072         vars.remove( 0, ind+1 );
1073     }
1074   }
1075
1076   if ( dlg() )
1077     dlg()->setMinimumSize( dlg()->minimumSizeHint().width(),
1078                            dlg()->minimumSizeHint().height() );
1079 }
1080
1081 //================================================================================
1082 /*!
1083  * \brief Transfer parameters from widgets to hypothesis
1084  */
1085 //================================================================================
1086
1087 QString StdMeshersGUI_CartesianParamCreator::storeParams() const
1088 {
1089   StdMeshers::StdMeshers_CartesianParameters3D_var h =
1090     StdMeshers::StdMeshers_CartesianParameters3D::_narrow( hypothesis() );
1091
1092   try
1093   {
1094     if( isCreation() )
1095       SMESH::SetName( SMESH::FindSObject( h ), myName->text().toUtf8().constData() );
1096
1097     // threshold
1098     h->SetVarParameter( myThreshold->text().toLatin1().constData(), "SetSizeThreshold" );
1099     h->SetSizeThreshold( myThreshold->text().toDouble() );
1100     h->SetToAddEdges( myAddEdges->isChecked() );
1101     h->SetToCreateFaces( myCreateFaces->isChecked() );
1102     h->SetToConsiderInternalFaces( myConsiderInternalFaces->isChecked() );
1103     h->SetToUseThresholdForInternalFaces( myUseThresholdForInternalFaces->isChecked() );
1104
1105     // grid
1106     for ( int ax = 0; ax < 3; ++ax )
1107     {
1108       if ( myAxisTabs[ax]->isGridBySpacing())
1109       {
1110         SMESH::double_array_var intPoints;
1111         SMESH::string_array_var funs;
1112         myAxisTabs[ax]->getSpacing( funs.out(), intPoints.out() );
1113         h->SetGridSpacing( funs, intPoints, ax );
1114       }
1115       else
1116       {
1117         SMESH::double_array_var coords = myAxisTabs[ax]->getCoordinates();
1118         h->SetGrid( coords, ax );
1119       }
1120     }
1121
1122     // fixed point
1123     QStringList params;
1124     params << myPointSpin[0]->text();
1125     params << myPointSpin[1]->text();
1126     params << myPointSpin[2]->text();
1127     h->SetVarParameter( params.join(":").toUtf8().constData(), "SetFixedPoint" );
1128     params.clear();
1129
1130     SMESH::PointStruct ps;
1131     ps.x = myPointSpin[0]->GetValue();
1132     ps.y = myPointSpin[1]->GetValue();
1133     ps.z = myPointSpin[2]->GetValue();
1134     h->SetFixedPoint( ps, !myFixedPointGrp->isEnabled() || !myFixedPointGrp->isChecked() );
1135
1136     // axes directions
1137     SMESHGUI_SpinBox* const * spins[3] = { &myXDirSpin[0], &myYDirSpin[0], &myZDirSpin[0] };
1138     for ( int ax = 0; ax < 3; ++ax )
1139     {
1140       params << spins[ax][0]->text();
1141       params << spins[ax][1]->text();
1142       params << spins[ax][2]->text();
1143     }
1144     h->SetVarParameter( params.join(":").toUtf8().constData(), "SetAxesDirs" );
1145
1146     SMESH::DirStruct axDir[3];
1147     for ( int ax = 0; ax < 3; ++ax )
1148     {
1149       axDir[ax].PS.x = spins[ax][0]->GetValue();
1150       axDir[ax].PS.y = spins[ax][1]->GetValue();
1151       axDir[ax].PS.z = spins[ax][2]->GetValue();
1152     }
1153     h->SetAxesDirs( axDir[0], axDir[1], axDir[2] );
1154
1155   }
1156   catch(const SALOME::SALOME_Exception& ex)
1157   {
1158     SalomeApp_Tools::QtCatchCorbaException(ex);
1159   }
1160   return "";
1161 }
1162
1163 //================================================================================
1164 /*!
1165  * \brief Returns a name of help page
1166  */
1167 //================================================================================
1168
1169 QString StdMeshersGUI_CartesianParamCreator::helpPage() const
1170 {
1171   return "cartesian_algo.html#cartesian-hyp-anchor";
1172 }
1173
1174 //================================================================================
1175 /*!
1176  * \brief Show axes if they are OK
1177  */
1178 //================================================================================
1179
1180 bool StdMeshersGUI_CartesianParamCreator::updateAxesPreview()
1181 {
1182   bool isOk = true;
1183   gp_Ax1 axes[3];
1184   SMESHGUI_SpinBox** spins[3] = { &myXDirSpin[0], &myYDirSpin[0], &myZDirSpin[0] };
1185   for ( int i = 0; i < 3 && isOk; ++i )
1186   {
1187     gp_XYZ dir( spins[i][0]->GetValue(),
1188                 spins[i][1]->GetValue(),
1189                 spins[i][2]->GetValue());
1190     if (( isOk = ( dir.Modulus() > 1e-100 )))
1191       axes[i].SetDirection( gp_Dir( dir ));
1192
1193     axes[i].SetLocation ( gp_Pnt( myOrigin[0],
1194                                   myOrigin[1],
1195                                   myOrigin[2]));
1196   }
1197   gp_Vec norm01 = axes[0].Direction().XYZ() ^ axes[1].Direction().XYZ();
1198   gp_Vec norm12 = axes[1].Direction().XYZ() ^ axes[2].Direction().XYZ();
1199   if ( isOk )
1200     isOk = ( !axes[0].Direction().IsParallel( axes[1].Direction(), theAngTol ) &&
1201              !axes[1].Direction().IsParallel( axes[2].Direction(), theAngTol ) &&
1202              !axes[2].Direction().IsParallel( axes[0].Direction(), theAngTol ) &&
1203              !norm01.IsParallel( norm12, theAngTol ) );
1204   if ( isOk )
1205     myAxesPreview->SetArrows( axes, myAxesLen );
1206
1207   myAxesPreview->SetVisibility( isOk );
1208
1209   return isOk;
1210 }
1211
1212 //================================================================================
1213 /*!
1214  * \brief Makes axes orthogonal if necessary
1215  */
1216 //================================================================================
1217
1218 void StdMeshersGUI_CartesianParamCreator::onOrthogonalAxes(bool isOrtho)
1219 {
1220   if ( !isOrtho )
1221   {
1222     updateAxesPreview();
1223     return;
1224   }
1225
1226   std::multimap< int, int > ageOfAxis;
1227   gp_XYZ dirs[3];
1228   SMESHGUI_SpinBox** spins[3] = { &myXDirSpin[0], &myYDirSpin[0], &myZDirSpin[0] };
1229   int nbOk = 0, isOk;
1230   for ( int iAx = 0; iAx < 3; ++iAx )
1231   {
1232     dirs[iAx].SetCoord( spins[iAx][0]->GetValue(),
1233                         spins[iAx][1]->GetValue(),
1234                         spins[iAx][2]->GetValue());
1235     if (( isOk = ( dirs[iAx].Modulus() > 1e-100 )))
1236       ageOfAxis.insert( std::make_pair( myDirTic[iAx], iAx ));
1237     else
1238       ageOfAxis.insert( std::make_pair( -1, iAx ));
1239     nbOk += isOk;
1240   }
1241   switch ( nbOk )
1242   {
1243   case 0:
1244   {
1245     dirs[0].SetCoord( 1, 0, 0 );
1246     dirs[1].SetCoord( 0, 1, 0 );
1247     dirs[2].SetCoord( 0, 0, 1 );
1248     break;
1249   }
1250   case 1:
1251   {
1252     int iOk = ageOfAxis.rbegin()->second;
1253     get3Dirs( iOk, dirs );
1254     break;
1255   }
1256   default:
1257     std::multimap< int, int >::reverse_iterator ag2ax = ageOfAxis.rbegin();
1258     int iOk1 = ag2ax->second;
1259     int iOk2 = (++ag2ax)->second;
1260     int iKo  = (++ag2ax)->second;
1261     if ( gp_Vec( dirs[ iOk1 ]).IsParallel( gp_Vec( dirs[ iOk2 ]), theAngTol ))
1262       std::swap( iOk2, iKo );
1263     if ( gp_Vec( dirs[ iOk1 ]).IsParallel( gp_Vec( dirs[ iOk2 ]), theAngTol ))
1264     {
1265       get3Dirs( iOk1, dirs );
1266     }
1267     else
1268     {
1269       dirs[ iKo  ] = dirs[ iOk1 ] ^ dirs[ iOk2 ];
1270       dirs[ iOk2 ] = dirs[ iKo  ] ^ dirs[ iOk1 ];
1271       if ( ( iOk1+1 ) % 3 != iOk2 )
1272         dirs[ iKo ].Reverse();
1273     }
1274   }
1275
1276   for ( int iAx = 0; iAx < 3; ++iAx )
1277   {
1278     double size = dirs[iAx].Modulus();
1279     if ( size > 1e-100 )
1280       dirs[iAx] /= size;
1281     for (int i = 0; i < 3; ++i )
1282     {
1283       bool isBlocked = spins[iAx][i]->blockSignals( true );
1284       spins[iAx][i]->SetValue( dirs[iAx].Coord( i+1 ));
1285       spins[iAx][i]->blockSignals( isBlocked );
1286     }
1287   }
1288
1289   updateAxesPreview();
1290 }
1291
1292 //================================================================================
1293 /*!
1294  * \brief Increment myDirTic and update the preview of axes
1295  */
1296 //================================================================================
1297
1298 void StdMeshersGUI_CartesianParamCreator::onAxisDirChange(const QString&)
1299 {
1300   QObject* changedSpin = sender();
1301   SMESHGUI_SpinBox** spins[3] = { &myXDirSpin[0], &myYDirSpin[0], &myZDirSpin[0] };
1302   for ( int iAx = 0; iAx < 3; ++iAx )
1303     if ( spins[iAx][0] == changedSpin ||
1304          spins[iAx][1] == changedSpin ||
1305          spins[iAx][2] == changedSpin )
1306     {
1307       myDirTic[ iAx ] = 1 + Max( Max( myDirTic[0], myDirTic[1] ), myDirTic[2] );
1308       break;
1309     }
1310
1311   onOrthogonalAxes( myOrthogonalChk->isChecked() );
1312 }
1313
1314 //================================================================================
1315 /*!
1316  * \brief Sets axis direction by a selected EDGE
1317  */
1318 //================================================================================
1319
1320 void StdMeshersGUI_CartesianParamCreator::onSelectionChange()
1321 {
1322   int iAxis = myAxisBtnGrp->checkedId();
1323   if ( iAxis < 0 )
1324     return;
1325
1326   SALOME_ListIO aList;
1327   SMESHGUI::GetSMESHGUI()->selectionMgr()->selectedObjects(aList);
1328
1329   TopoDS_Shape edge, shape;
1330   for( SALOME_ListIteratorOfListIO anIt( aList ); anIt.More(); anIt.Next() )
1331   {
1332     GEOM::GEOM_Object_var go = SMESH::IObjectToInterface<GEOM::GEOM_Object>( anIt.Value() );
1333     if ( GEOMBase::GetShape( go, shape ) && shape.ShapeType() == TopAbs_EDGE )
1334     {
1335       if ( !edge.IsNull() )
1336         return; // several EDGEs selected
1337       edge = shape;
1338     }
1339   }
1340   if ( edge.IsNull() )
1341     return;
1342
1343   TopoDS_Shape vv[2];
1344   TopoDS_Iterator vIt( edge );
1345   for ( ; vIt.More() && vv[1].IsNull(); vIt.Next() )
1346     vv[ !vv[0].IsNull() ] = vIt.Value();
1347
1348   gp_Pnt pp[2];
1349   if ( !GEOMBase::VertexToPoint( vv[0], pp[0] ) ||
1350        !GEOMBase::VertexToPoint( vv[1], pp[1] ))
1351     return;
1352
1353   SMESHGUI_SpinBox** spins[3] = { &myXDirSpin[0], &myYDirSpin[0], &myZDirSpin[0] };
1354
1355   gp_Vec newDir( pp[0], pp[1] );
1356   gp_Vec curDir( spins[iAxis][0]->GetValue(),
1357                  spins[iAxis][1]->GetValue(),
1358                  spins[iAxis][2]->GetValue());
1359   if ( newDir * curDir < 0 )
1360     newDir.Reverse();
1361
1362   double size = newDir.Magnitude();
1363   if ( size < 1e-100 )
1364     return;
1365   newDir /= size;
1366
1367   for (int i = 0; i < 3; ++i )
1368   {
1369     bool isBlocked = spins[iAxis][i]->blockSignals( true );
1370     spins[iAxis][i]->SetValue( newDir.Coord( i+1 ));
1371     spins[iAxis][i]->blockSignals( isBlocked );
1372   }
1373   myDirTic[ iAxis ] = 1 + Max( Max( myDirTic[0], myDirTic[1] ), myDirTic[2] );
1374
1375   onOrthogonalAxes( myOrthogonalChk->isChecked() );
1376 }
1377
1378 //================================================================================
1379 /*!
1380  * \brief Sets axes at which number of hexahedra is maximal
1381  */
1382 //================================================================================
1383
1384 void StdMeshersGUI_CartesianParamCreator::onOptimalAxes(bool)
1385 {
1386   StdMeshers::StdMeshers_CartesianParameters3D_var h =
1387     StdMeshers::StdMeshers_CartesianParameters3D::_narrow( hypothesis() );
1388   if ( h->_is_nil() )
1389     return;
1390
1391   QString shapeEntry = getMainShapeEntry();
1392   if ( shapeEntry.isEmpty() )
1393     return;
1394
1395   GEOM::GEOM_Object_var geomObj = SMESH::EntryToInterface<GEOM::GEOM_Object>( shapeEntry );
1396   if ( geomObj->_is_nil() )
1397     return;
1398
1399   SMESH::DirStruct axDirs[3];
1400   h->ComputeOptimalAxesDirs( geomObj,
1401                              myOrthogonalChk->isChecked(),
1402                              axDirs[0],
1403                              axDirs[1],
1404                              axDirs[2]);
1405
1406   SMESHGUI_SpinBox** spins[3] = { &myXDirSpin[0], &myYDirSpin[0], &myZDirSpin[0] };
1407   for ( int iAx = 0; iAx < 3; ++iAx )
1408   {
1409     double coords[3] = { axDirs[iAx].PS.x, axDirs[iAx].PS.y, axDirs[iAx].PS.z };
1410     for (int i = 0; i < 3; ++i )
1411     {
1412       bool isBlocked = spins[iAx][i]->blockSignals( true );
1413       spins[iAx][i]->SetValue( coords[ i ]);
1414       spins[iAx][i]->blockSignals( isBlocked );
1415     }
1416   }
1417   updateAxesPreview();
1418 }
1419
1420 //================================================================================
1421 /*!
1422  * \brief Sets axes || to the axes of global CS
1423  */
1424 //================================================================================
1425
1426 void StdMeshersGUI_CartesianParamCreator::onResetAxes(bool)
1427 {
1428   SMESHGUI_SpinBox** spins[3] = { &myXDirSpin[0], &myYDirSpin[0], &myZDirSpin[0] };
1429   for ( int iAx = 0; iAx < 3; ++iAx )
1430   {
1431     for (int i = 0; i < 3; ++i )
1432     {
1433       bool isBlocked = spins[iAx][i]->blockSignals( true );
1434       spins[iAx][i]->SetValue( iAx == i ? 1. : 0. );
1435       spins[iAx][i]->blockSignals( isBlocked );
1436     }
1437     myDirTic[iAx] = 0;
1438   }
1439   updateAxesPreview();
1440 }
1441
1442 //================================================================================
1443 /*!
1444  * \brief SLOT called when the grid definition mode changes
1445  */
1446 //================================================================================
1447
1448 void StdMeshersGUI_CartesianParamCreator::onGridModeChanged(int)
1449 {
1450   bool haveSpacing = ( myAxisTabs[0]->isGridBySpacing() ||
1451                        myAxisTabs[1]->isGridBySpacing() ||
1452                        myAxisTabs[2]->isGridBySpacing() );
1453
1454   myFixedPointGrp->setEnabled( haveSpacing );
1455 }