src/SMESHGUI/SMESHGUI_Measurements.cxx

   1 // Copyright (C) 2007-2014  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   : SMESHGUI_Measurements.cxx
  23 //  Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
  24
  25 #include "SMESHGUI_Measurements.h"
  26
  27 #include "SMESH_Actor.h"
  28 #include "SMESHGUI.h"
  29 #include "SMESHGUI_IdValidator.h"
  30 #include "SMESHGUI_Utils.h"
  31 #include "SMESHGUI_VTKUtils.h"
  32 #include <SMESH_TypeFilter.hxx>
  33 #include <SMESH_LogicalFilter.hxx>
  34
  35 #include <LightApp_SelectionMgr.h>
  36 #include <SUIT_OverrideCursor.h>
  37 #include <SUIT_ResourceMgr.h>
  38 #include <SVTK_ViewWindow.h>
  39 #include <SALOME_ListIteratorOfListIO.hxx>
  40
  41 #include <QButtonGroup>
  42 #include <QGridLayout>
  43 #include <QGroupBox>
  44 #include <QHBoxLayout>
  45 #include <QKeyEvent>
  46 #include <QLabel>
  47 #include <QLineEdit>
  48 #include <QPushButton>
  49 #include <QRadioButton>
  50 #include <QTabWidget>
  51 #include <QVBoxLayout>
  52
  53 #include <vtkPoints.h>
  54 #include <vtkUnstructuredGrid.h>
  55 #include <vtkIdList.h>
  56 #include <vtkCellArray.h>
  57 #include <vtkUnsignedCharArray.h>
  58 #include <vtkDataSetMapper.h>
  59 #include <VTKViewer_CellLocationsArray.h>
  60 #include <vtkProperty.h>
  61
  62 #include <SALOMEconfig.h>
  63 #include CORBA_SERVER_HEADER(SMESH_MeshEditor)
  64 #include CORBA_SERVER_HEADER(SMESH_Measurements)
  65
  66 const int SPACING = 6;            // layout spacing
  67 const int MARGIN  = 9;            // layout margin
  68 const int MAX_NB_FOR_EDITOR = 40; // max nb of items in the ID list editor field
  69
  70 // Uncomment as soon as elements are supported by Min Distance operation
  71 //#define MINDIST_ENABLE_ELEMENT
  72
  73 // Uncomment as soon as objects are supported by Min Distance operation
  74 //#define MINDIST_ENABLE_OBJECT
  75
  76 /*!
  77   \class SMESHGUI_MinDistance
  78   \brief Minimum distance measurement widget.
  79
  80   Widget to calculate minimum distance between two objects.
  81 */
  82
  83 /*!
  84   \brief Constructor.
  85   \param parent parent widget
  86 */
  87 SMESHGUI_MinDistance::SMESHGUI_MinDistance( QWidget* parent )
  88 : QWidget( parent ), myCurrentTgt( FirstTgt ), myFirstActor( 0 ), mySecondActor( 0 ), myPreview( 0 )
  89 {
  90   QGroupBox*    aFirstTgtGrp = new QGroupBox( tr( "FIRST_TARGET" ), this );
  91   QRadioButton* aFNode       = new QRadioButton( tr( "NODE" ),    aFirstTgtGrp );
  92   QRadioButton* aFElem       = new QRadioButton( tr( "ELEMENT" ), aFirstTgtGrp );
  93   QRadioButton* aFObject     = new QRadioButton( tr( "OBJECT" ),  aFirstTgtGrp );
  94   myFirstTgt                 = new QLineEdit( aFirstTgtGrp );
  95
  96   QGridLayout* fl = new QGridLayout( aFirstTgtGrp );
  97   fl->setMargin( MARGIN );
  98   fl->setSpacing( SPACING );
  99   fl->addWidget( aFNode,     0, 0 );
 100   fl->addWidget( aFElem,     0, 1 );
 101   fl->addWidget( aFObject,   0, 2 );
 102   fl->addWidget( myFirstTgt, 1, 0, 1, 3 );
 103
 104   myFirst = new QButtonGroup( this );
 105   myFirst->addButton( aFNode,   NodeTgt );
 106   myFirst->addButton( aFElem,   ElementTgt );
 107   myFirst->addButton( aFObject, ObjectTgt );
 108
 109   QGroupBox*    aSecondTgtGrp = new QGroupBox( tr( "SECOND_TARGET" ), this );
 110   QRadioButton* aSOrigin      = new QRadioButton( tr( "ORIGIN" ),  aSecondTgtGrp );
 111   QRadioButton* aSNode        = new QRadioButton( tr( "NODE" ),    aSecondTgtGrp );
 112   QRadioButton* aSElem        = new QRadioButton( tr( "ELEMENT" ), aSecondTgtGrp );
 113   QRadioButton* aSObject      = new QRadioButton( tr( "OBJECT" ),  aSecondTgtGrp );
 114   mySecondTgt                 = new QLineEdit( aSecondTgtGrp );
 115
 116   QGridLayout* sl = new QGridLayout( aSecondTgtGrp );
 117   sl->setMargin( MARGIN );
 118   sl->setSpacing( SPACING );
 119   sl->addWidget( aSOrigin,   0, 0 );
 120   sl->addWidget( aSNode,     0, 1 );
 121   sl->addWidget( aSElem,     0, 2 );
 122   sl->addWidget( aSObject,   0, 3 );
 123   sl->addWidget( mySecondTgt, 1, 0, 1, 4 );
 124
 125   mySecond = new QButtonGroup( this );
 126   mySecond->addButton( aSOrigin, OriginTgt );
 127   mySecond->addButton( aSNode,   NodeTgt );
 128   mySecond->addButton( aSElem,   ElementTgt );
 129   mySecond->addButton( aSObject, ObjectTgt );
 130
 131   QPushButton* aCompute = new QPushButton( tr( "COMPUTE" ), this );
 132
 133   QGroupBox* aResults = new QGroupBox( tr( "RESULT" ), this );
 134   QLabel* aDxLab   = new QLabel( "dX", aResults );
 135   myDX             = new QLineEdit( aResults );
 136   QLabel* aDyLab   = new QLabel( "dY", aResults );
 137   myDY             = new QLineEdit( aResults );
 138   QLabel* aDzLab   = new QLabel( "dZ", aResults );
 139   myDZ             = new QLineEdit( aResults );
 140   QLabel* aDistLab = new QLabel( tr( "DISTANCE" ), aResults );
 141   myDistance       = new QLineEdit( aResults );
 142
 143   QGridLayout* rl = new QGridLayout( aResults );
 144   rl->setMargin( MARGIN );
 145   rl->setSpacing( SPACING );
 146   rl->addWidget( aDxLab,     0, 0 );
 147   rl->addWidget( myDX,       0, 1 );
 148   rl->addWidget( aDyLab,     1, 0 );
 149   rl->addWidget( myDY,       1, 1 );
 150   rl->addWidget( aDzLab,     2, 0 );
 151   rl->addWidget( myDZ,       2, 1 );
 152   rl->addWidget( aDistLab,   0, 2 );
 153   rl->addWidget( myDistance, 0, 3 );
 154
 155   QGridLayout* l = new QGridLayout( this );
 156   l->setMargin( MARGIN );
 157   l->setSpacing( SPACING );
 158
 159   l->addWidget( aFirstTgtGrp,  0, 0, 1, 2 );
 160   l->addWidget( aSecondTgtGrp, 1, 0, 1, 2 );
 161   l->addWidget( aCompute,      2, 0 );
 162   l->addWidget( aResults,      3, 0, 1, 2 );
 163   l->setColumnStretch( 1, 5 );
 164   l->setRowStretch( 4, 5 );
 165
 166   aFNode->setChecked( true );
 167   aSOrigin->setChecked( true );
 168 #ifndef MINDIST_ENABLE_ELEMENT
 169   aFElem->setEnabled( false );   // NOT AVAILABLE YET
 170   aSElem->setEnabled( false );   // NOT AVAILABLE YET
 171 #endif
 172 #ifndef MINDIST_ENABLE_OBJECT
 173   aFObject->setEnabled( false ); // NOT AVAILABLE YET
 174   aSObject->setEnabled( false ); // NOT AVAILABLE YET
 175 #endif
 176   myDX->setReadOnly( true );
 177   myDY->setReadOnly( true );
 178   myDZ->setReadOnly( true );
 179   myDistance->setReadOnly( true );
 180
 181   myValidator = new SMESHGUI_IdValidator( this, 1 );
 182
 183   myFirstTgt->installEventFilter( this );
 184   mySecondTgt->installEventFilter( this );
 185
 186   connect( myFirst,     SIGNAL( buttonClicked( int ) ),  this, SLOT( firstChanged() ) );
 187   connect( mySecond,    SIGNAL( buttonClicked( int ) ),  this, SLOT( secondChanged() ) );
 188   connect( aCompute,    SIGNAL( clicked() ),             this, SLOT( compute() ) );
 189   connect( myFirstTgt,  SIGNAL( textEdited( QString ) ), this, SLOT( firstEdited() ) );
 190   connect( mySecondTgt, SIGNAL( textEdited( QString ) ), this, SLOT( secondEdited() ) );
 191
 192   QList<SUIT_SelectionFilter*> filters;
 193   filters.append( new SMESH_TypeFilter( SMESH::MESHorSUBMESH ) );
 194   filters.append( new SMESH_TypeFilter( SMESH::GROUP ) );
 195   myFilter = new SMESH_LogicalFilter( filters, SMESH_LogicalFilter::LO_OR );
 196
 197   mySecondTgt->setEnabled( mySecond->checkedId() != OriginTgt );
 198   clear();
 199
 200   //setTarget( FirstTgt );
 201 }
 202
 203 /*!
 204   \brief Destructor
 205 */
 206 SMESHGUI_MinDistance::~SMESHGUI_MinDistance()
 207 {
 208   erasePreview();
 209   if ( myPreview )
 210     myPreview->Delete();
 211 }
 212
 213 /*!
 214   \brief Event filter
 215   \param o object
 216   \param o event
 217   \return \c true if event is filtered or \c false otherwise
 218 */
 219 bool SMESHGUI_MinDistance::eventFilter( QObject* o, QEvent* e )
 220 {
 221   if ( e->type() == QEvent::FocusIn ) {
 222     if ( o == myFirstTgt )
 223       setTarget( FirstTgt );
 224     else if ( o == mySecondTgt )
 225       setTarget( SecondTgt );
 226   }
 227   return QWidget::eventFilter( o, e );
 228 }
 229
 230 /*!
 231   \brief Setup selection mode depending on the current widget state
 232 */
 233 void SMESHGUI_MinDistance::updateSelection()
 234 {
 235   LightApp_SelectionMgr* selMgr = SMESHGUI::selectionMgr();
 236
 237   disconnect( selMgr, 0, this, 0 );
 238   selMgr->clearFilters();
 239
 240   bool nodeMode = ( myCurrentTgt == FirstTgt  && myFirst->checkedId() == NodeTgt ) ||
 241                   ( myCurrentTgt == SecondTgt && mySecond->checkedId() == NodeTgt );
 242   bool elemMode = ( myCurrentTgt == FirstTgt  && myFirst->checkedId() == ElementTgt ) ||
 243                   ( myCurrentTgt == SecondTgt && mySecond->checkedId() == ElementTgt );
 244   bool objMode  = ( myCurrentTgt == FirstTgt  && myFirst->checkedId() == ObjectTgt ) ||
 245                   ( myCurrentTgt == SecondTgt && mySecond->checkedId() == ObjectTgt ) ||
 246                   ( myCurrentTgt == NoTgt );
 247
 248   if ( nodeMode ) {
 249     SMESH::SetPointRepresentation( true );
 250     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
 251       aViewWindow->SetSelectionMode( NodeSelection );
 252   }
 253   else if ( elemMode ) {
 254     SMESH::SetPointRepresentation( false );
 255     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
 256       aViewWindow->SetSelectionMode( CellSelection );
 257   }
 258   else if ( objMode ) {
 259     SMESH::SetPointRepresentation( false );
 260     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
 261       aViewWindow->SetSelectionMode( ActorSelection );
 262     selMgr->installFilter( myFilter );
 263   }
 264
 265   connect( selMgr, SIGNAL( currentSelectionChanged() ), this, SLOT( selectionChanged() ) );
 266
 267   if ( myCurrentTgt == FirstTgt )
 268     firstEdited();
 269   else if ( myCurrentTgt == SecondTgt )
 270     secondEdited();
 271
 272   //selectionChanged();
 273 }
 274
 275 /*!
 276   \brief Deactivate widget
 277 */
 278 void SMESHGUI_MinDistance::deactivate()
 279 {
 280   disconnect( SMESHGUI::selectionMgr(), 0, this, 0 );
 281 }
 282
 283 /*!
 284   \brief Set current target for selection
 285   \param target new target ID
 286 */
 287 void SMESHGUI_MinDistance::setTarget( int target )
 288 {
 289   if ( myCurrentTgt != target ) {
 290     myCurrentTgt = target;
 291     updateSelection();
 292   }
 293 }
 294
 295 /*!
 296   \brief Erase preview actor
 297 */
 298 void SMESHGUI_MinDistance::erasePreview()
 299 {
 300   SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
 301   if ( aViewWindow && myPreview ) {
 302     aViewWindow->RemoveActor( myPreview );
 303     aViewWindow->Repaint();
 304   }
 305 }
 306
 307 /*!
 308   \brief Display preview actor
 309 */
 310 void SMESHGUI_MinDistance::displayPreview()
 311 {
 312   SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
 313   if ( aViewWindow && myPreview ) {
 314     aViewWindow->AddActor( myPreview );
 315     aViewWindow->Repaint();
 316   }
 317 }
 318
 319 /*!
 320   \brief Create preview actor
 321   \param x1 X coordinate of first point
 322   \param y1 X coordinate of first point
 323   \param z1 Y coordinate of first point
 324   \param x2 Y coordinate of second point
 325   \param y2 Z coordinate of second point
 326   \param z2 Z coordinate of second point
 327 */
 328 void SMESHGUI_MinDistance::createPreview( double x1, double y1, double z1, double x2, double y2, double z2 )
 329 {
 330   if ( myPreview )
 331     myPreview->Delete();
 332
 333   vtkUnstructuredGrid* aGrid = vtkUnstructuredGrid::New();
 334   // create points
 335   vtkPoints* aPoints = vtkPoints::New();
 336   aPoints->SetNumberOfPoints( 2 );
 337   aPoints->SetPoint( 0, x1, y1, z1 );
 338   aPoints->SetPoint( 1, x2, y2, z2 );
 339   aGrid->SetPoints( aPoints );
 340   aPoints->Delete();
 341   // create cells
 342   vtkIdList* anIdList = vtkIdList::New();
 343   anIdList->SetNumberOfIds( 2 );
 344   vtkCellArray* aCells = vtkCellArray::New();
 345   aCells->Allocate( 2, 0);
 346   vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
 347   aCellTypesArray->SetNumberOfComponents( 1 );
 348   aCellTypesArray->Allocate( 1 );
 349   anIdList->SetId( 0, 0 ); anIdList->SetId( 1, 1 );
 350   aCells->InsertNextCell( anIdList );
 351   aCellTypesArray->InsertNextValue( VTK_LINE );
 352   anIdList->Delete();
 353   VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
 354   aCellLocationsArray->SetNumberOfComponents( 1 );
 355   aCellLocationsArray->SetNumberOfTuples( 1 );
 356   aCells->InitTraversal();
 357   for( vtkIdType idType = 0, *pts, npts; aCells->GetNextCell( npts, pts ); idType++ )
 358     aCellLocationsArray->SetValue( idType, aCells->GetTraversalLocation( npts ) );
 359   aGrid->SetCells( aCellTypesArray, aCellLocationsArray, aCells );
 360   aCellLocationsArray->Delete();
 361   aCellTypesArray->Delete();
 362   aCells->Delete();
 363   // create actor
 364   vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
 365   aMapper->SetInputData( aGrid );
 366   aGrid->Delete();
 367   myPreview = SALOME_Actor::New();
 368   myPreview->PickableOff();
 369   myPreview->SetMapper( aMapper );
 370   aMapper->Delete();
 371   vtkProperty* aProp = vtkProperty::New();
 372   aProp->SetRepresentationToWireframe();
 373   aProp->SetColor( 250, 0, 250 );
 374   aProp->SetPointSize( 5 );
 375   aProp->SetLineWidth( 3 );
 376   myPreview->SetProperty( aProp );
 377   aProp->Delete();
 378 }
 379
 380 /*!
 381   \brief Called when selection is changed
 382 */
 383 void SMESHGUI_MinDistance::selectionChanged()
 384 {
 385   SUIT_OverrideCursor wc;
 386
 387   SALOME_ListIO selected;
 388   SMESHGUI::selectionMgr()->selectedObjects( selected );
 389
 390   if ( selected.Extent() == 1 ) {
 391     Handle(SALOME_InteractiveObject) IO = selected.First();
 392     SMESH::SMESH_IDSource_var obj = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
 393     if ( !CORBA::is_nil( obj ) ) {
 394       if ( myCurrentTgt == FirstTgt ) {
 395         myFirstSrc = obj;
 396         myFirstActor = SMESH::FindActorByEntry( IO->getEntry() );
 397         if ( myFirst->checkedId() == ObjectTgt ) {
 398           QString aName;
 399           SMESH::GetNameOfSelectedIObjects( SMESHGUI::selectionMgr(), aName );
 400           myFirstTgt->setText( aName );
 401         }
 402         else {
 403           SVTK_Selector* selector = SMESH::GetViewWindow()->GetSelector();
 404           QString ID;
 405           int nb = 0;
 406           if ( myFirstActor && selector ) {
 407             nb = myFirst->checkedId() == NodeTgt ?
 408               SMESH::GetNameOfSelectedElements( selector, IO, ID ) :
 409               SMESH::GetNameOfSelectedNodes( selector, IO, ID );
 410           }
 411           if ( nb == 1 )
 412             myFirstTgt->setText( ID.trimmed() );
 413           else
 414             myFirstTgt->clear();
 415         }
 416       }
 417       else if ( myCurrentTgt == SecondTgt ) {
 418         mySecondSrc = obj;
 419         mySecondActor = SMESH::FindActorByEntry( IO->getEntry() );
 420         if ( mySecond->checkedId() == ObjectTgt ) {
 421           QString aName;
 422           SMESH::GetNameOfSelectedIObjects( SMESHGUI::selectionMgr(), aName );
 423           mySecondTgt->setText( aName );
 424         }
 425         else {
 426           SVTK_Selector* selector = SMESH::GetViewWindow()->GetSelector();
 427           QString ID;
 428           int nb = 0;
 429           if ( mySecondActor && selector ) {
 430             nb = mySecond->checkedId() == NodeTgt ?
 431               SMESH::GetNameOfSelectedElements( selector, IO, ID ) :
 432               SMESH::GetNameOfSelectedNodes( selector, IO, ID );
 433           }
 434           if ( nb == 1 )
 435             mySecondTgt->setText( ID.trimmed() );
 436           else
 437             mySecondTgt->clear();
 438         }
 439       }
 440     }
 441   }
 442   clear();
 443 }
 444
 445 /*!
 446   \brief Called when first target mode is changed by the user
 447 */
 448 void SMESHGUI_MinDistance::firstChanged()
 449 {
 450   myFirstSrc = SMESH::SMESH_IDSource::_nil();
 451   myFirstTgt->clear();
 452   myFirstTgt->setReadOnly( myFirst->checkedId() == ObjectTgt );
 453   myFirstTgt->setValidator( myFirst->checkedId() == ObjectTgt ? 0 : myValidator );
 454   setTarget( FirstTgt );
 455   updateSelection();
 456   clear();
 457 }
 458
 459 /*!
 460   \brief Called when second target mode is changed by the user
 461 */
 462 void SMESHGUI_MinDistance::secondChanged()
 463 {
 464   mySecondSrc = SMESH::SMESH_IDSource::_nil();
 465   mySecondTgt->setEnabled( mySecond->checkedId() != OriginTgt );
 466   mySecondTgt->setReadOnly( mySecond->checkedId() == ObjectTgt );
 467   mySecondTgt->setValidator( mySecond->checkedId() == ObjectTgt ? 0 : myValidator );
 468   mySecondTgt->clear();
 469   setTarget( mySecond->checkedId() != OriginTgt ? SecondTgt : NoTgt );
 470   updateSelection();
 471   clear();
 472 }
 473
 474 /*!
 475   \brief Called when first target is edited by the user
 476 */
 477 void SMESHGUI_MinDistance::firstEdited()
 478 {
 479   setTarget( FirstTgt );
 480   if ( sender() == myFirstTgt )
 481     clear();
 482   SVTK_Selector* selector = SMESH::GetViewWindow()->GetSelector();
 483   if ( myFirstActor && selector ) {
 484     Handle(SALOME_InteractiveObject) IO = myFirstActor->getIO();
 485     if ( myFirst->checkedId() == NodeTgt || myFirst->checkedId() == ElementTgt ) {
 486       TColStd_MapOfInteger ID;
 487       ID.Add( myFirstTgt->text().toLong() );
 488       selector->AddOrRemoveIndex( IO, ID, false );
 489     }
 490     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
 491       aViewWindow->highlight( IO, true, true );
 492   }
 493 }
 494
 495 /*!
 496   \brief Called when second target is edited by the user
 497 */
 498 void SMESHGUI_MinDistance::secondEdited()
 499 {
 500   setTarget( SecondTgt );
 501   if ( sender() == mySecondTgt )
 502     clear();
 503   SVTK_Selector* selector = SMESH::GetViewWindow()->GetSelector();
 504   if ( mySecondActor && selector ) {
 505     Handle(SALOME_InteractiveObject) IO = mySecondActor->getIO();
 506     if ( mySecond->checkedId() == NodeTgt || mySecond->checkedId() == ElementTgt ) {
 507       TColStd_MapOfInteger ID;
 508       ID.Add( mySecondTgt->text().toLong() );
 509       selector->AddOrRemoveIndex( IO, ID, false );
 510     }
 511     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
 512       aViewWindow->highlight( IO, true, true );
 513   }
 514 }
 515
 516 /*!
 517   \brief Compute the minimum distance between targets
 518 */
 519 void SMESHGUI_MinDistance::compute()
 520 {
 521   SUIT_OverrideCursor wc;
 522   SMESH::SMESH_IDSource_wrap s1;
 523   SMESH::SMESH_IDSource_wrap s2;
 524   bool isOrigin = mySecond->checkedId() == OriginTgt;
 525
 526   // process first target
 527   if ( !CORBA::is_nil( myFirstSrc ) ) {
 528     if ( myFirst->checkedId() == NodeTgt || myFirst->checkedId() == ElementTgt ) {
 529       SMESH::SMESH_Mesh_var m = myFirstSrc->GetMesh();
 530       long id = myFirstTgt->text().toLong();
 531       if ( !CORBA::is_nil( m ) && id ) {
 532         SMESH::long_array_var ids = new SMESH::long_array();
 533         ids->length( 1 );
 534         ids[0] = id;
 535         SMESH::SMESH_MeshEditor_var me = m->GetMeshEditor();
 536         s1 = me->MakeIDSource( ids.in(), myFirst->checkedId() == NodeTgt ? SMESH::NODE : SMESH::FACE );
 537       }
 538     }
 539     else {
 540       s1 = myFirstSrc;
 541       s1->Register();
 542     }
 543   }
 544
 545   // process second target
 546   if ( !CORBA::is_nil( mySecondSrc ) ) {
 547     if ( mySecond->checkedId() == NodeTgt || mySecond->checkedId() == ElementTgt ) {
 548       SMESH::SMESH_Mesh_var m = mySecondSrc->GetMesh();
 549       long id = mySecondTgt->text().toLong();
 550       if ( !CORBA::is_nil( m ) && id ) {
 551         SMESH::long_array_var ids = new SMESH::long_array();
 552         ids->length( 1 );
 553         ids[0] = id;
 554         SMESH::SMESH_MeshEditor_var me = m->GetMeshEditor();
 555         s2 = me->MakeIDSource( ids.in(), mySecond->checkedId() == NodeTgt ? SMESH::NODE : SMESH::FACE );
 556       }
 557     }
 558     else {
 559       s2 = mySecondSrc;
 560       s2->Register();
 561     }
 562   }
 563
 564   if ( !CORBA::is_nil( s1 ) && ( !CORBA::is_nil( s2 ) || isOrigin ) ) {
 565     // compute min distance
 566     int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
 567     SMESH::Measurements_var measure = SMESHGUI::GetSMESHGen()->CreateMeasurements();
 568     SMESH::Measure result = measure->MinDistance( s1.in(), s2.in() );
 569     measure->UnRegister();
 570     myDX->setText( QString::number( result.minX, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
 571     myDY->setText( QString::number( result.minY, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
 572     myDZ->setText( QString::number( result.minZ, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
 573     myDistance->setText( QString::number( result.value, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
 574     // update preview actor
 575     erasePreview();
 576     double x1, y1, z1, x2, y2, z2;
 577     SMESH::double_array_var coord = s1->GetMesh()->GetNodeXYZ( result.node1 );
 578     x1 = coord[0]; y1 = coord[1]; z1 = coord[2];
 579     if ( isOrigin ) {
 580       x2 = y2 = z2 = 0.;
 581     }
 582     else {
 583       coord = s2->GetMesh()->GetNodeXYZ( result.node2 );
 584       x2 = coord[0]; y2 = coord[1]; z2 = coord[2];
 585     }
 586     createPreview( x1, y1, z1, x2, y2, z2 );
 587     displayPreview();
 588   }
 589   else {
 590     clear();
 591   }
 592 }
 593
 594 /*!
 595   \brief Reset the widget to the initial state (nullify result fields)
 596 */
 597 void SMESHGUI_MinDistance::clear()
 598 {
 599   myDX->clear();
 600   myDY->clear();
 601   myDZ->clear();
 602   myDistance->clear();
 603   erasePreview();
 604 }
 605
 606 /*!
 607   \class SMESHGUI_BoundingBox
 608   \brief Bounding box measurement widget.
 609
 610   Widget to calculate bounding box of the selected object(s).
 611 */
 612
 613 /*!
 614   \brief Constructor.
 615   \param parent parent widget
 616 */
 617 SMESHGUI_BoundingBox::SMESHGUI_BoundingBox( QWidget* parent )
 618 : QWidget( parent ), myActor( 0 ), myPreview( 0 )
 619 {
 620   QGroupBox* aSourceGrp = new QGroupBox( tr( "SOURCE" ), this );
 621   QRadioButton* aObjects  = new QRadioButton( tr( "OBJECTS" ),  aSourceGrp );
 622   QRadioButton* aNodes    = new QRadioButton( tr( "NODES" ),    aSourceGrp );
 623   QRadioButton* aElements = new QRadioButton( tr( "ELEMENTS" ), aSourceGrp );
 624   mySource = new QLineEdit( aSourceGrp );
 625
 626   QGridLayout* fl = new QGridLayout( aSourceGrp );
 627   fl->setMargin( MARGIN );
 628   fl->setSpacing( SPACING );
 629   fl->addWidget( aObjects,   0, 0 );
 630   fl->addWidget( aNodes,     0, 1 );
 631   fl->addWidget( aElements,  0, 2 );
 632   fl->addWidget( mySource,   1, 0, 1, 3 );
 633
 634   mySourceMode = new QButtonGroup( this );
 635   mySourceMode->addButton( aObjects,  ObjectsSrc );
 636   mySourceMode->addButton( aNodes,    NodesSrc );
 637   mySourceMode->addButton( aElements, ElementsSrc );
 638
 639   QPushButton* aCompute = new QPushButton( tr( "COMPUTE" ), this );
 640
 641   QGroupBox* aResults = new QGroupBox( tr( "RESULT" ), this );
 642   QLabel* aXminLab = new QLabel( "Xmin", aResults );
 643   myXmin           = new QLineEdit( aResults );
 644   QLabel* aXmaxLab = new QLabel( "Xmax", aResults );
 645   myXmax           = new QLineEdit( aResults );
 646   QLabel* aDxLab   = new QLabel( "dX", aResults );
 647   myDX             = new QLineEdit( aResults );
 648   QLabel* aYminLab = new QLabel( "Ymin", aResults );
 649   myYmin           = new QLineEdit( aResults );
 650   QLabel* aYmaxLab = new QLabel( "Ymax", aResults );
 651   myYmax           = new QLineEdit( aResults );
 652   QLabel* aDyLab   = new QLabel( "dY", aResults );
 653   myDY             = new QLineEdit( aResults );
 654   QLabel* aZminLab = new QLabel( "Zmin", aResults );
 655   myZmin           = new QLineEdit( aResults );
 656   QLabel* aZmaxLab = new QLabel( "Zmax", aResults );
 657   myZmax           = new QLineEdit( aResults );
 658   QLabel* aDzLab   = new QLabel( "dZ", aResults );
 659   myDZ             = new QLineEdit( aResults );
 660
 661   QGridLayout* rl  = new QGridLayout( aResults );
 662   rl->setMargin( MARGIN );
 663   rl->setSpacing( SPACING );
 664   rl->addWidget( aXminLab,   0, 0 );
 665   rl->addWidget( myXmin,     0, 1 );
 666   rl->addWidget( aXmaxLab,   0, 2 );
 667   rl->addWidget( myXmax,     0, 3 );
 668   rl->addWidget( aDxLab,     0, 4 );
 669   rl->addWidget( myDX,       0, 5 );
 670   rl->addWidget( aYminLab,   1, 0 );
 671   rl->addWidget( myYmin,     1, 1 );
 672   rl->addWidget( aYmaxLab,   1, 2 );
 673   rl->addWidget( myYmax,     1, 3 );
 674   rl->addWidget( aDyLab,     1, 4 );
 675   rl->addWidget( myDY,       1, 5 );
 676   rl->addWidget( aZminLab,   2, 0 );
 677   rl->addWidget( myZmin,     2, 1 );
 678   rl->addWidget( aZmaxLab,   2, 2 );
 679   rl->addWidget( myZmax,     2, 3 );
 680   rl->addWidget( aDzLab,     2, 4 );
 681   rl->addWidget( myDZ,       2, 5 );
 682
 683   QGridLayout* l = new QGridLayout( this );
 684   l->setMargin( MARGIN );
 685   l->setSpacing( SPACING );
 686
 687   l->addWidget( aSourceGrp, 0, 0, 1, 2 );
 688   l->addWidget( aCompute,   1, 0 );
 689   l->addWidget( aResults,   2, 0, 1, 2 );
 690   l->setColumnStretch( 1, 5 );
 691   l->setRowStretch( 3, 5 );
 692
 693   aObjects->setChecked( true );
 694   myXmin->setReadOnly( true );
 695   myXmax->setReadOnly( true );
 696   myDX->setReadOnly( true );
 697   myYmin->setReadOnly( true );
 698   myYmax->setReadOnly( true );
 699   myDY->setReadOnly( true );
 700   myZmin->setReadOnly( true );
 701   myZmax->setReadOnly( true );
 702   myDZ->setReadOnly( true );
 703
 704   myValidator = new SMESHGUI_IdValidator( this );
 705
 706   connect( mySourceMode, SIGNAL( buttonClicked( int ) ),  this, SLOT( sourceChanged() ) );
 707   connect( aCompute,     SIGNAL( clicked() ),             this, SLOT( compute() ) );
 708   connect( mySource,     SIGNAL( textEdited( QString ) ), this, SLOT( sourceEdited() ) );
 709
 710   QList<SUIT_SelectionFilter*> filters;
 711   filters.append( new SMESH_TypeFilter( SMESH::MESHorSUBMESH ) );
 712   filters.append( new SMESH_TypeFilter( SMESH::GROUP ) );
 713   myFilter = new SMESH_LogicalFilter( filters, SMESH_LogicalFilter::LO_OR );
 714
 715   clear();
 716 }
 717
 718 /*!
 719   \brief Destructor
 720 */
 721 SMESHGUI_BoundingBox::~SMESHGUI_BoundingBox()
 722 {
 723   erasePreview();
 724   if ( myPreview )
 725     myPreview->Delete();
 726 }
 727
 728 /*!
 729   \brief Setup selection mode depending on the current widget state
 730 */
 731 void SMESHGUI_BoundingBox::updateSelection()
 732 {
 733   LightApp_SelectionMgr* selMgr = SMESHGUI::selectionMgr();
 734
 735   disconnect( selMgr, 0, this, 0 );
 736   selMgr->clearFilters();
 737
 738   bool nodeMode = mySourceMode->checkedId() == NodesSrc;
 739   bool elemMode = mySourceMode->checkedId() == ElementsSrc;
 740   bool objMode  = mySourceMode->checkedId() == ObjectsSrc;
 741
 742   if ( nodeMode ) {
 743     SMESH::SetPointRepresentation( true );
 744     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
 745       aViewWindow->SetSelectionMode( NodeSelection );
 746   }
 747   else if ( elemMode ) {
 748     SMESH::SetPointRepresentation( false );
 749     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
 750       aViewWindow->SetSelectionMode( CellSelection );
 751   }
 752   else if ( objMode ) {
 753     SMESH::SetPointRepresentation( false );
 754     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
 755       aViewWindow->SetSelectionMode( ActorSelection );
 756     selMgr->installFilter( myFilter );
 757   }
 758
 759   connect( selMgr, SIGNAL( currentSelectionChanged() ), this, SLOT( selectionChanged() ) );
 760
 761   sourceEdited();
 762
 763   //selectionChanged();
 764 }
 765
 766 /*!
 767   \brief Deactivate widget
 768 */
 769 void SMESHGUI_BoundingBox::deactivate()
 770 {
 771   disconnect( SMESHGUI::selectionMgr(), 0, this, 0 );
 772 }
 773
 774 /*!
 775   \brief Erase preview actor
 776 */
 777 void SMESHGUI_BoundingBox::erasePreview()
 778 {
 779   SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
 780   if ( aViewWindow && myPreview ) {
 781     aViewWindow->RemoveActor( myPreview );
 782     aViewWindow->Repaint();
 783   }
 784 }
 785
 786 /*!
 787   \brief Display preview actor
 788 */
 789 void SMESHGUI_BoundingBox::displayPreview()
 790 {
 791   SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
 792   if ( aViewWindow && myPreview ) {
 793     aViewWindow->AddActor( myPreview );
 794     aViewWindow->Repaint();
 795   }
 796 }
 797
 798 /*!
 799   \brief Create preview actor
 800   \param minX min X coordinate of bounding box
 801   \param maxX max X coordinate of bounding box
 802   \param minY min Y coordinate of bounding box
 803   \param maxY max Y coordinate of bounding box
 804   \param minZ min Z coordinate of bounding box
 805   \param maxZ max Z coordinate of bounding box
 806 */
 807 void SMESHGUI_BoundingBox::createPreview( double minX, double maxX, double minY, double maxY, double minZ, double maxZ )
 808 {
 809   if ( myPreview )
 810     myPreview->Delete();
 811
 812   vtkUnstructuredGrid* aGrid = vtkUnstructuredGrid::New();
 813   // create points
 814   vtkPoints* aPoints = vtkPoints::New();
 815   aPoints->SetNumberOfPoints( 8 );
 816   aPoints->SetPoint( 0, minX, minY, minZ );
 817   aPoints->SetPoint( 1, maxX, minY, minZ );
 818   aPoints->SetPoint( 2, minX, maxY, minZ );
 819   aPoints->SetPoint( 3, maxX, maxY, minZ );
 820   aPoints->SetPoint( 4, minX, minY, maxZ );
 821   aPoints->SetPoint( 5, maxX, minY, maxZ );
 822   aPoints->SetPoint( 6, minX, maxY, maxZ );
 823   aPoints->SetPoint( 7, maxX, maxY, maxZ );
 824   aGrid->SetPoints( aPoints );
 825   aPoints->Delete();
 826   // create cells
 827   // connectivity: 0-1 0-4 0-2 1-5 1-3 2-6 2-3 3-7 4-6 4-5 5-7 6-7
 828   vtkIdList* anIdList = vtkIdList::New();
 829   anIdList->SetNumberOfIds( 2 );
 830   vtkCellArray* aCells = vtkCellArray::New();
 831   aCells->Allocate( 2*12, 0);
 832   vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
 833   aCellTypesArray->SetNumberOfComponents( 1 );
 834   aCellTypesArray->Allocate( 12 );
 835   anIdList->SetId( 0, 0 ); anIdList->SetId( 1, 1 );
 836   aCells->InsertNextCell( anIdList );
 837   aCellTypesArray->InsertNextValue( VTK_LINE );
 838   anIdList->SetId( 0, 0 ); anIdList->SetId( 1, 4 );
 839   aCells->InsertNextCell( anIdList );
 840   aCellTypesArray->InsertNextValue( VTK_LINE );
 841   anIdList->SetId( 0, 0 ); anIdList->SetId( 1, 2 );
 842   aCells->InsertNextCell( anIdList );
 843   aCellTypesArray->InsertNextValue( VTK_LINE );
 844   anIdList->SetId( 0, 1 ); anIdList->SetId( 1, 5 );
 845   aCells->InsertNextCell( anIdList );
 846   aCellTypesArray->InsertNextValue( VTK_LINE );
 847   anIdList->SetId( 0, 1 ); anIdList->SetId( 1, 3 );
 848   aCells->InsertNextCell( anIdList );
 849   aCellTypesArray->InsertNextValue( VTK_LINE );
 850   anIdList->SetId( 0, 2 ); anIdList->SetId( 1, 6 );
 851   aCells->InsertNextCell( anIdList );
 852   aCellTypesArray->InsertNextValue( VTK_LINE );
 853   anIdList->SetId( 0, 2 ); anIdList->SetId( 1, 3 );
 854   aCells->InsertNextCell( anIdList );
 855   aCellTypesArray->InsertNextValue( VTK_LINE );
 856   anIdList->SetId( 0, 3 ); anIdList->SetId( 1, 7 );
 857   aCells->InsertNextCell( anIdList );
 858   aCellTypesArray->InsertNextValue( VTK_LINE );
 859   anIdList->SetId( 0, 4 ); anIdList->SetId( 1, 6 );
 860   aCells->InsertNextCell( anIdList );
 861   aCellTypesArray->InsertNextValue( VTK_LINE );
 862   anIdList->SetId( 0, 4 ); anIdList->SetId( 1, 5 );
 863   aCells->InsertNextCell( anIdList );
 864   aCellTypesArray->InsertNextValue( VTK_LINE );
 865   anIdList->SetId( 0, 5 ); anIdList->SetId( 1, 7 );
 866   aCells->InsertNextCell( anIdList );
 867   aCellTypesArray->InsertNextValue( VTK_LINE );
 868   anIdList->SetId( 0, 6 ); anIdList->SetId( 1, 7 );
 869   aCells->InsertNextCell( anIdList );
 870   aCellTypesArray->InsertNextValue( VTK_LINE );
 871   anIdList->Delete();
 872   VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
 873   aCellLocationsArray->SetNumberOfComponents( 1 );
 874   aCellLocationsArray->SetNumberOfTuples( 12 );
 875   aCells->InitTraversal();
 876   for( vtkIdType idType = 0, *pts, npts; aCells->GetNextCell( npts, pts ); idType++ )
 877     aCellLocationsArray->SetValue( idType, aCells->GetTraversalLocation( npts ) );
 878   aGrid->SetCells( aCellTypesArray, aCellLocationsArray, aCells );
 879   aCellLocationsArray->Delete();
 880   aCellTypesArray->Delete();
 881   aCells->Delete();
 882   // create actor
 883   vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
 884   aMapper->SetInputData( aGrid );
 885   aGrid->Delete();
 886   myPreview = SALOME_Actor::New();
 887   myPreview->PickableOff();
 888   myPreview->SetMapper( aMapper );
 889   aMapper->Delete();
 890   vtkProperty* aProp = vtkProperty::New();
 891   aProp->SetRepresentationToWireframe();
 892   aProp->SetColor( 250, 0, 250 );
 893   aProp->SetPointSize( 5 );
 894   aProp->SetLineWidth( 3 );
 895   myPreview->SetProperty( aProp );
 896   aProp->Delete();
 897 }
 898
 899 /*!
 900   \brief Called when selection is changed
 901 */
 902 void SMESHGUI_BoundingBox::selectionChanged()
 903 {
 904   SUIT_OverrideCursor wc;
 905
 906   SALOME_ListIO selected;
 907   SMESHGUI::selectionMgr()->selectedObjects( selected );
 908
 909   if ( selected.Extent() == 1 ) {
 910     Handle(SALOME_InteractiveObject) IO = selected.First();
 911     SMESH::SMESH_IDSource_var obj = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
 912     if ( !CORBA::is_nil( obj ) ) {
 913       mySrc.clear();
 914       mySrc.append( obj );
 915       myActor = SMESH::FindActorByEntry( IO->getEntry() );
 916       if ( mySourceMode->checkedId() == ObjectsSrc ) {
 917         QString aName;
 918         SMESH::GetNameOfSelectedIObjects( SMESHGUI::selectionMgr(), aName );
 919         mySource->setText( aName );
 920       }
 921       else {
 922         SVTK_Selector* selector = SMESH::GetViewWindow()->GetSelector();
 923         QString ID;
 924         int nb = 0;
 925         if ( myActor && selector ) {
 926           nb = mySourceMode->checkedId() == NodesSrc ?
 927             SMESH::GetNameOfSelectedElements( selector, IO, ID ) :
 928             SMESH::GetNameOfSelectedNodes( selector, IO, ID );
 929         }
 930         if ( nb > 0 ) {
 931           myIDs = ID.trimmed();
 932           if ( nb < MAX_NB_FOR_EDITOR ) {
 933             mySource->setReadOnly( false );
 934             if ( mySource->validator() != myValidator )
 935               mySource->setValidator( myValidator );
 936             mySource->setText( ID.trimmed() );
 937           }
 938           else {
 939             mySource->setReadOnly( true );
 940             mySource->setValidator( 0 );
 941             mySource->setText( tr( "SELECTED_NB_OBJ" ).arg( nb )
 942                                .arg( mySourceMode->checkedId() == NodesSrc ? tr( "NB_NODES" ) : tr( "NB_ELEMENTS") ) );
 943           }
 944         }
 945         else {
 946           myIDs = "";
 947           mySource->clear();
 948           mySource->setReadOnly( false );
 949           mySource->setValidator( myValidator );
 950         }
 951       }
 952     }
 953   }
 954   else if ( selected.Extent() > 1 ) {
 955     myIDs = "";
 956     SALOME_ListIteratorOfListIO It( selected );
 957     mySrc.clear();
 958     myActor = 0;
 959     if ( mySourceMode->checkedId() == ObjectsSrc ) {
 960       for( ; It.More(); It.Next()){
 961         Handle(SALOME_InteractiveObject) IO = It.Value();
 962         SMESH::SMESH_IDSource_var obj = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
 963         if ( !CORBA::is_nil( obj ) ) {
 964           mySrc.append( obj );
 965         }
 966       }
 967       QString aName;
 968       SMESH::GetNameOfSelectedIObjects( SMESHGUI::selectionMgr(), aName );
 969       mySource->setText( aName );
 970     }
 971     else {
 972       mySource->clear();
 973     }
 974   }
 975   clear();
 976 }
 977
 978 /*!
 979   \brief Called when source mode is changed by the user
 980 */
 981 void SMESHGUI_BoundingBox::sourceChanged()
 982 {
 983   myIDs = "";
 984   mySource->clear();
 985   mySource->setReadOnly( mySourceMode->checkedId() == ObjectsSrc );
 986   mySource->setValidator( mySourceMode->checkedId() == ObjectsSrc ? 0 : myValidator );
 987   updateSelection();
 988   clear();
 989 }
 990
 991 /*!
 992   \brief Called when source mode is edited by the user
 993 */
 994 void SMESHGUI_BoundingBox::sourceEdited()
 995 {
 996   if ( sender() == mySource )
 997     clear();
 998   SVTK_Selector* selector = SMESH::GetViewWindow()->GetSelector();
 999   if ( myActor && selector ) {
1000     Handle(SALOME_InteractiveObject) IO = myActor->getIO();
1001     if ( mySourceMode->checkedId() == NodesSrc || mySourceMode->checkedId() == ElementsSrc ) {
1002       TColStd_MapOfInteger ID;
1003       if ( !mySource->isReadOnly() )
1004         myIDs = mySource->text();
1005       QStringList ids = myIDs.split( " ", QString::SkipEmptyParts );
1006       foreach ( QString id, ids )
1007         ID.Add( id.trimmed().toLong() );
1008       selector->AddOrRemoveIndex( IO, ID, false );
1009     }
1010     if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
1011       aViewWindow->highlight( IO, true, true );
1012   }
1013 }
1014
1015 /*!
1016   \brief Calculate bounding box of the selected object(s)
1017 */
1018 void SMESHGUI_BoundingBox::compute()
1019 {
1020   SUIT_OverrideCursor wc;
1021   SMESH::ListOfIDSources_var srcList = new SMESH::ListOfIDSources();
1022   if ( mySourceMode->checkedId() == NodesSrc || mySourceMode->checkedId() == ElementsSrc ) {
1023     if ( mySrc.count() > 0 && !CORBA::is_nil( mySrc[0] ) ) {
1024       SMESH::SMESH_Mesh_var m = mySrc[0]->GetMesh();
1025       QStringList ids = myIDs.split( " ", QString::SkipEmptyParts );
1026       if ( !CORBA::is_nil( m ) && ids.count() > 0 ) {
1027         SMESH::long_array_var ids_in = new SMESH::long_array();
1028         ids_in->length( ids.count() );
1029         for( int i = 0; i < ids.count(); i++ )
1030           ids_in[i] = ids[i].trimmed().toLong();
1031         SMESH::SMESH_MeshEditor_var me = m->GetMeshEditor();
1032         SMESH::SMESH_IDSource_var s = me->MakeIDSource( ids_in.in(), mySourceMode->checkedId() == NodesSrc ? SMESH::NODE : SMESH::FACE );
1033         srcList->length( 1 );
1034         srcList[0] = s;
1035       }
1036     }
1037   }
1038   else {
1039     srcList->length( mySrc.count() );
1040     for( int i = 0; i < mySrc.count(); i++ ) {
1041       srcList[i] = mySrc[i];
1042       mySrc[i]->Register();
1043     }
1044   }
1045   if ( srcList->length() > 0 ) {
1046     // compute bounding box
1047     int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
1048     SMESH::Measurements_var measure = SMESHGUI::GetSMESHGen()->CreateMeasurements();
1049     SMESH::Measure result = measure->BoundingBox( srcList.in() );
1050     SALOME::UnRegister( srcList );
1051     measure->UnRegister();
1052     myXmin->setText( QString::number( result.minX, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1053     myXmax->setText( QString::number( result.maxX, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1054     myDX->setText( QString::number( result.maxX-result.minX, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1055     myYmin->setText( QString::number( result.minY, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1056     myYmax->setText( QString::number( result.maxY, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1057     myDY->setText( QString::number( result.maxY-result.minY, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1058     myZmin->setText( QString::number( result.minZ, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1059     myZmax->setText( QString::number( result.maxZ, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1060     myDZ->setText( QString::number( result.maxZ-result.minZ, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1061     // update preview actor
1062     erasePreview();
1063     createPreview( result.minX, result.maxX, result.minY, result.maxY, result.minZ, result.maxZ );
1064     displayPreview();
1065   }
1066   else {
1067     clear();
1068   }
1069 }
1070
1071 /*!
1072   \brief Reset the widget to the initial state (nullify result fields)
1073 */
1074 void SMESHGUI_BoundingBox::clear()
1075 {
1076   myXmin->clear();
1077   myXmax->clear();
1078   myDX->clear();
1079   myYmin->clear();
1080   myYmax->clear();
1081   myDY->clear();
1082   myZmin->clear();
1083   myZmax->clear();
1084   myDZ->clear();
1085   erasePreview();
1086 }
1087
1088 /*!
1089   \class SMESHGUI_BasicProperties
1090   \brief basic properties measurement widget.
1091
1092   Widget to calculate length, area or volume for the selected object(s).
1093 */
1094
1095 /*!
1096   \brief Constructor.
1097   \param parent parent widget
1098 */
1099 SMESHGUI_BasicProperties::SMESHGUI_BasicProperties( QWidget* parent )
1100 : QWidget( parent )
1101 {
1102   // Property (length, area or volume)
1103   QGroupBox* aPropertyGrp = new QGroupBox( tr( "PROPERTY" ), this );
1104
1105   QRadioButton* aLength = new QRadioButton( tr( "LENGTH" ), aPropertyGrp );
1106   QRadioButton* anArea = new QRadioButton( tr( "AREA" ), aPropertyGrp );
1107   QRadioButton* aVolume = new QRadioButton( tr( "VOLUME" ), aPropertyGrp );
1108
1109   myMode = new QButtonGroup( this );
1110   myMode->addButton( aLength, Length );
1111   myMode->addButton( anArea, Area );
1112   myMode->addButton( aVolume, Volume );
1113
1114   QHBoxLayout* aPropertyLayout = new QHBoxLayout;
1115   aPropertyLayout->addWidget( aLength );
1116   aPropertyLayout->addWidget( anArea );
1117   aPropertyLayout->addWidget( aVolume );
1118
1119   aPropertyGrp->setLayout( aPropertyLayout );
1120
1121   // Source object
1122   QGroupBox* aSourceGrp = new QGroupBox( tr( "SOURCE_MESH_SUBMESH_GROUP" ), this );
1123
1124   mySource = new QLineEdit( aSourceGrp );
1125   mySource->setReadOnly( true );
1126
1127   QHBoxLayout* aSourceLayout = new QHBoxLayout;
1128   aSourceLayout->addWidget( mySource );
1129
1130   aSourceGrp->setLayout( aSourceLayout );
1131
1132   // Compute button
1133   QPushButton* aCompute = new QPushButton( tr( "COMPUTE" ), this );
1134
1135   // Result of computation (length, area or volume)
1136   myResultGrp = new QGroupBox( this );
1137
1138   myResult = new QLineEdit;
1139   myResult->setReadOnly( true );
1140
1141   QHBoxLayout* aResultLayout = new QHBoxLayout;
1142   aResultLayout->addWidget( myResult );
1143
1144   myResultGrp->setLayout( aResultLayout );
1145
1146   // Layout
1147   QGridLayout* aMainLayout = new QGridLayout( this );
1148   aMainLayout->setMargin( MARGIN );
1149   aMainLayout->setSpacing( SPACING );
1150
1151   aMainLayout->addWidget( aPropertyGrp, 0, 0, 1, 2 );
1152   aMainLayout->addWidget( aSourceGrp, 1, 0, 1, 2 );
1153   aMainLayout->addWidget( aCompute,   2, 0 );
1154   aMainLayout->addWidget( myResultGrp, 3, 0, 1, 2 );
1155   aMainLayout->setColumnStretch( 1, 5 );
1156   aMainLayout->setRowStretch( 4, 5 );
1157
1158   // Initial state
1159   setMode( Length );
1160
1161   // Connections
1162   connect( myMode, SIGNAL( buttonClicked( int ) ),  this, SLOT( modeChanged( int ) ) );
1163   connect( aCompute, SIGNAL( clicked() ), this, SLOT( compute() ) );
1164
1165   // Selection filter
1166   QList<SUIT_SelectionFilter*> filters;
1167   filters.append( new SMESH_TypeFilter( SMESH::MESHorSUBMESH ) );
1168   filters.append( new SMESH_TypeFilter( SMESH::GROUP ) );
1169   myFilter = new SMESH_LogicalFilter( filters, SMESH_LogicalFilter::LO_OR );
1170 }
1171
1172 /*!
1173   \brief Destructor
1174 */
1175 SMESHGUI_BasicProperties::~SMESHGUI_BasicProperties()
1176 {
1177 }
1178
1179 /*!
1180   \brief Sets the measurement mode.
1181   \param theMode the mode to set (length, area or volume meausurement)
1182 */
1183 void SMESHGUI_BasicProperties::setMode( const Mode theMode )
1184 {
1185   QRadioButton* aButton = qobject_cast<QRadioButton*>( myMode->button( theMode ) );
1186   if ( aButton ) {
1187     aButton->setChecked( true );
1188     modeChanged( theMode );
1189   }
1190 }
1191
1192 /*!
1193   \brief Setup the selection mode.
1194 */
1195 void SMESHGUI_BasicProperties::updateSelection()
1196 {
1197   LightApp_SelectionMgr* selMgr = SMESHGUI::selectionMgr();
1198
1199   disconnect( selMgr, 0, this, 0 );
1200   selMgr->clearFilters();
1201
1202   SMESH::SetPointRepresentation( false );
1203   if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() ) {
1204     aViewWindow->SetSelectionMode( ActorSelection );
1205   }
1206   selMgr->installFilter( myFilter );
1207
1208   connect( selMgr, SIGNAL( currentSelectionChanged() ), this, SLOT( selectionChanged() ) );
1209 }
1210
1211 /*!
1212   \brief Deactivate widget
1213 */
1214 void SMESHGUI_BasicProperties::deactivate()
1215 {
1216   disconnect( SMESHGUI::selectionMgr(), 0, this, 0 );
1217 }
1218
1219 /*!
1220   \brief Called when selection is changed
1221 */
1222 void SMESHGUI_BasicProperties::selectionChanged()
1223 {
1224   SUIT_OverrideCursor wc;
1225
1226   SALOME_ListIO selected;
1227   SMESHGUI::selectionMgr()->selectedObjects( selected );
1228
1229   if ( selected.Extent() == 1 ) {
1230     Handle(SALOME_InteractiveObject) IO = selected.First();
1231     SMESH::SMESH_IDSource_var obj = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
1232     if ( !CORBA::is_nil( obj ) ) {
1233       mySrc = obj;
1234
1235       QString aName;
1236       SMESH::GetNameOfSelectedIObjects( SMESHGUI::selectionMgr(), aName );
1237       mySource->setText( aName );
1238     }
1239   }
1240
1241   clear();
1242 }
1243
1244 /*!
1245   \brief Called when the measurement mode selection is changed.
1246   \param theMode the selected mode
1247 */
1248 void SMESHGUI_BasicProperties::modeChanged( int theMode )
1249 {
1250   clear();
1251
1252   if ( theMode == Length ) {
1253     myResultGrp->setTitle( tr("LENGTH") );
1254   } else if ( theMode == Area ) {
1255     myResultGrp->setTitle( tr("AREA") );
1256   } else if ( theMode == Volume ) {
1257     myResultGrp->setTitle( tr("VOLUME") );
1258   }
1259 }
1260
1261 /*!
1262   \brief Calculate length, area or volume for the selected object(s)
1263 */
1264 void SMESHGUI_BasicProperties::compute()
1265 {
1266   SUIT_OverrideCursor wc;
1267
1268   SMESH::SMESH_IDSource_var source;
1269
1270   if ( !CORBA::is_nil( mySrc ) ) {
1271     // compute
1272     int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
1273     SMESH::Measurements_var measure = SMESHGUI::GetSMESHGen()->CreateMeasurements();
1274
1275     double result = 0;
1276
1277     if ( myMode->checkedId() == Length ) {
1278       result = measure->Length( mySrc.in() );
1279     } else if ( myMode->checkedId() == Area ) {
1280       result = measure->Area( mySrc.in() );
1281     } else if ( myMode->checkedId() == Volume ) {
1282       result = measure->Volume( mySrc.in() );
1283     }
1284
1285     measure->UnRegister();
1286
1287     myResult->setText( QString::number( result, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1288   } else {
1289     clear();
1290   }
1291 }
1292
1293 /*!
1294   \brief Reset the widget to the initial state (nullify the result field)
1295 */
1296 void SMESHGUI_BasicProperties::clear()
1297 {
1298   myResult->clear();
1299 }
1300
1301 /*!
1302   \class SMESHGUI_MeshInfoDlg
1303   \brief Centralized dialog box for the measurements
1304 */
1305
1306 /*!
1307   \brief Constructor
1308   \param parent parent widget
1309   \param page specifies the dialog page to be shown at the start-up
1310 */
1311 SMESHGUI_MeasureDlg::SMESHGUI_MeasureDlg( QWidget* parent, int page )
1312 : QDialog( parent )
1313 {
1314   setModal( false );
1315   setAttribute( Qt::WA_DeleteOnClose, true );
1316   setWindowTitle( tr( "MEASUREMENTS" ) );
1317   setSizeGripEnabled( true );
1318
1319   SUIT_ResourceMgr* resMgr = SMESHGUI::resourceMgr();
1320
1321   myTabWidget = new QTabWidget( this );
1322
1323   // min distance
1324
1325   myMinDist = new SMESHGUI_MinDistance( myTabWidget );
1326   int aMinDistInd = myTabWidget->addTab( myMinDist, resMgr->loadPixmap( "SMESH", tr( "ICON_MEASURE_MIN_DIST" ) ), tr( "MIN_DIST" ) );
1327
1328   // bounding box
1329
1330   myBndBox = new SMESHGUI_BoundingBox( myTabWidget );
1331   int aBndBoxInd = myTabWidget->addTab( myBndBox, resMgr->loadPixmap( "SMESH", tr( "ICON_MEASURE_BND_BOX" ) ), tr( "BND_BOX" ) );
1332
1333   // basic properties
1334
1335   myBasicProps = new SMESHGUI_BasicProperties( myTabWidget );
1336   int aBasicPropInd = myTabWidget->addTab( myBasicProps, resMgr->loadPixmap( "SMESH", tr( "ICON_MEASURE_BASIC_PROPS" ) ), tr( "BASIC_PROPERTIES" ) );
1337
1338   // buttons
1339   QPushButton* okBtn = new QPushButton( tr( "SMESH_BUT_OK" ), this );
1340   okBtn->setAutoDefault( true );
1341   okBtn->setDefault( true );
1342   okBtn->setFocus();
1343   QPushButton* helpBtn = new QPushButton( tr( "SMESH_BUT_HELP" ), this );
1344   helpBtn->setAutoDefault( true );
1345
1346   QHBoxLayout* btnLayout = new QHBoxLayout;
1347   btnLayout->setSpacing( SPACING );
1348   btnLayout->setMargin( 0 );
1349   btnLayout->addWidget( okBtn );
1350   btnLayout->addStretch( 10 );
1351   btnLayout->addWidget( helpBtn );
1352
1353   QVBoxLayout* l = new QVBoxLayout ( this );
1354   l->setMargin( MARGIN );
1355   l->setSpacing( SPACING );
1356   l->addWidget( myTabWidget );
1357   l->addStretch();
1358   l->addLayout( btnLayout );
1359
1360   int anInd = -1;
1361   if ( page == MinDistance ) {
1362     anInd = aMinDistInd;
1363   } else if ( page == BoundingBox ) {
1364     anInd = aBndBoxInd;
1365   } else if ( page == Length || page == Area || page == Volume ) {
1366     myBasicProps->setMode( (SMESHGUI_BasicProperties::Mode)(page - Length) );
1367     anInd = aBasicPropInd;
1368   }
1369
1370   if ( anInd >= 0 ) {
1371     myTabWidget->setCurrentIndex( anInd );
1372   }
1373
1374   connect( okBtn,       SIGNAL( clicked() ),              this, SLOT( reject() ) );
1375   connect( helpBtn,     SIGNAL( clicked() ),              this, SLOT( help() ) );
1376   connect( myTabWidget, SIGNAL( currentChanged( int  ) ), this, SLOT( updateSelection() ) );
1377   connect( SMESHGUI::GetSMESHGUI(),  SIGNAL( SignalDeactivateActiveDialog() ), this, SLOT( deactivate() ) );
1378   connect( SMESHGUI::GetSMESHGUI(),  SIGNAL( SignalCloseAllDialogs() ),        this, SLOT( reject() ) );
1379
1380   updateSelection();
1381 }
1382
1383 /*!
1384   \brief Destructor
1385 */
1386 SMESHGUI_MeasureDlg::~SMESHGUI_MeasureDlg()
1387 {
1388 }
1389
1390 /*!
1391   \brief Perform clean-up actions on the dialog box closing.
1392 */
1393 void SMESHGUI_MeasureDlg::reject()
1394 {
1395   LightApp_SelectionMgr* selMgr = SMESHGUI::selectionMgr();
1396   selMgr->clearFilters();
1397   SMESH::SetPointRepresentation( false );
1398   if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
1399     aViewWindow->SetSelectionMode( ActorSelection );
1400   QDialog::reject();
1401 }
1402
1403 /*!
1404   \brief Process keyboard event
1405   \param e key press event
1406 */
1407 void SMESHGUI_MeasureDlg::keyPressEvent( QKeyEvent* e )
1408 {
1409   QDialog::keyPressEvent( e );
1410   if ( !e->isAccepted() && e->key() == Qt::Key_F1 ) {
1411     e->accept();
1412     help();
1413   }
1414 }
1415
1416 /*!
1417   \brief Reactivate dialog box, when mouse pointer goes into it.
1418 */
1419 void SMESHGUI_MeasureDlg::enterEvent( QEvent* )
1420 {
1421   activate();
1422 }
1423
1424 /*!
1425   \brief Setup selection mode depending on the current dialog box state.
1426 */
1427 void SMESHGUI_MeasureDlg::updateSelection()
1428 {
1429   if ( myTabWidget->currentIndex() == MinDistance )
1430     myMinDist->updateSelection();
1431   else if ( myTabWidget->currentIndex() == BoundingBox )
1432     myBndBox->updateSelection();
1433   else {
1434     myBndBox->erasePreview();
1435     myBasicProps->updateSelection();
1436   }
1437 }
1438
1439 /*!
1440   \brief Show help page
1441 */
1442 void SMESHGUI_MeasureDlg::help()
1443 {
1444   QString aHelpFile;
1445   if ( myTabWidget->currentIndex() == MinDistance ) {
1446     aHelpFile = "measurements_page.html#min_distance_anchor";
1447   } else if ( myTabWidget->currentIndex() == BoundingBox ) {
1448     aHelpFile = "measurements_page.html#bounding_box_anchor";
1449   } else {
1450     aHelpFile = "measurements_page.html#basic_properties_anchor";
1451   }
1452
1453   SMESH::ShowHelpFile( aHelpFile );
1454 }
1455
1456 /*!
1457   \brief Activate dialog box
1458 */
1459 void SMESHGUI_MeasureDlg::activate()
1460 {
1461   SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1462   SMESHGUI::GetSMESHGUI()->SetActiveDialogBox( this );
1463   myTabWidget->setEnabled( true );
1464   updateSelection();
1465 }
1466
1467 /*!
1468   \brief Deactivate dialog box
1469 */
1470 void SMESHGUI_MeasureDlg::deactivate()
1471 {
1472   myBasicProps->deactivate();
1473   myMinDist->deactivate();
1474   myBndBox->deactivate();
1475   myTabWidget->setEnabled( false );
1476   disconnect( SMESHGUI::selectionMgr(), SIGNAL( currentSelectionChanged() ), this, SLOT( updateInfo() ) );
1477 }