src/SMESHGUI/SMESHGUI.cxx

   1 // Copyright (C) 2007-2016  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.cxx
  23 //  Author : Nicolas REJNERI, Open CASCADE S.A.S.
  24
  25 #include <Standard_math.hxx>  // E.A. must be included before Python.h to fix compilation on windows
  26 #ifdef HAVE_FINITE
  27 #undef HAVE_FINITE            // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
  28 #endif
  29 #include "Python.h"
  30
  31 //  SMESH includes
  32 #include "SMESHGUI.h"
  33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
  34 #include "SMESHGUI_AddMeshElementDlg.h"
  35 #include "SMESHGUI_AddQuadraticElementDlg.h"
  36 #include "SMESHGUI_BuildCompoundDlg.h"
  37 #include "SMESHGUI_ClippingDlg.h"
  38 #include "SMESHGUI_ComputeDlg.h"
  39 #include "SMESHGUI_ConvToQuadOp.h"
  40 #include "SMESHGUI_CopyMeshDlg.h"
  41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
  42 #include "SMESHGUI_DeleteGroupDlg.h"
  43 #include "SMESHGUI_Displayer.h"
  44 #include "SMESHGUI_DuplicateNodesDlg.h"
  45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
  46 #include "SMESHGUI_ExtrusionDlg.h"
  47 #include "SMESHGUI_FieldSelectorWdg.h"
  48 #include "SMESHGUI_FileInfoDlg.h"
  49 #include "SMESHGUI_FileValidator.h"
  50 #include "SMESHGUI_FilterDlg.h"
  51 #include "SMESHGUI_FilterLibraryDlg.h"
  52 #include "SMESHGUI_FindElemByPointDlg.h"
  53 #include "SMESHGUI_GroupDlg.h"
  54 #include "SMESHGUI_GroupOnShapeDlg.h"
  55 #include "SMESHGUI_GroupOpDlg.h"
  56 #include "SMESHGUI_Hypotheses.h"
  57 #include "SMESHGUI_Make2DFrom3DOp.h"
  58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
  59 #include "SMESHGUI_Measurements.h"
  60 #include "SMESHGUI_MergeDlg.h"
  61 #include "SMESHGUI_MeshInfo.h"
  62 #include "SMESHGUI_MeshOp.h"
  63 #include "SMESHGUI_MeshOrderOp.h"
  64 #include "SMESHGUI_MeshPatternDlg.h"
  65 #include "SMESHGUI_MultiEditDlg.h"
  66 #include "SMESHGUI_NodesDlg.h"
  67 #include "SMESHGUI_Operations.h"
  68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
  69 #include "SMESHGUI_PropertiesDlg.h"
  70 #include "SMESHGUI_RemoveElementsDlg.h"
  71 #include "SMESHGUI_RemoveNodesDlg.h"
  72 #include "SMESHGUI_RenumberingDlg.h"
  73 #include "SMESHGUI_ReorientFacesDlg.h"
  74 #include "SMESHGUI_RevolutionDlg.h"
  75 #include "SMESHGUI_RotationDlg.h"
  76 #include "SMESHGUI_ScaleDlg.h"
  77 #include "SMESHGUI_Selection.h"
  78 #include "SMESHGUI_SewingDlg.h"
  79 #include "SMESHGUI_SingleEditDlg.h"
  80 #include "SMESHGUI_SmoothingDlg.h"
  81 #include "SMESHGUI_SymmetryDlg.h"
  82 #include "SMESHGUI_TranslationDlg.h"
  83 #include "SMESHGUI_TransparencyDlg.h"
  84 #include "SMESHGUI_DisplayEntitiesDlg.h"
  85 #include "SMESHGUI_SplitBiQuad.h"
  86
  87 #include "SMESHGUI_FilterUtils.h"
  88 #include "SMESHGUI_GEOMGenUtils.h"
  89 #include "SMESHGUI_GroupUtils.h"
  90 #include "SMESHGUI_HypothesesUtils.h"
  91 #include "SMESHGUI_MeshUtils.h"
  92 #include "SMESHGUI_PatternUtils.h"
  93 #include "SMESHGUI_Utils.h"
  94 #include "SMESHGUI_VTKUtils.h"
  95
  96 #include "SMESH_version.h"
  97
  98 #include "SMESH_ControlsDef.hxx"
  99 #include "SMESH_Actor.h"
 100 #include "SMESH_ActorUtils.h"
 101 #include "SMESH_Client.hxx"
 102 #include "SMESH_ScalarBarActor.h"
 103 #include "SMESH_TypeFilter.hxx"
 104
 105 // SALOME GUI includes
 106 #include <SalomeApp_Application.h>
 107 #include <SalomeApp_CheckFileDlg.h>
 108 #include <SalomeApp_DataObject.h>
 109 #include <SalomeApp_Study.h>
 110 #include <SalomeApp_Tools.h>
 111
 112 #include <LightApp_DataOwner.h>
 113 #include <LightApp_NameDlg.h>
 114 #include <LightApp_Preferences.h>
 115 #include <LightApp_SelectionMgr.h>
 116 #include <LightApp_UpdateFlags.h>
 117
 118 #include <SVTK_ViewManager.h>
 119 #include <SVTK_ViewModel.h>
 120 #include <SVTK_ViewWindow.h>
 121
 122 #include <VTKViewer_Algorithm.h>
 123
 124 #include <SUIT_Desktop.h>
 125 #include <SUIT_FileDlg.h>
 126 #include <SUIT_MessageBox.h>
 127 #include <SUIT_OverrideCursor.h>
 128 #include <SUIT_ResourceMgr.h>
 129 #include <SUIT_Session.h>
 130
 131 #include <QtxPopupMgr.h>
 132 #include <QtxFontEdit.h>
 133
 134 #include <SALOME_ListIO.hxx>
 135
 136 #ifndef DISABLE_PLOT2DVIEWER
 137 #include <SPlot2d_ViewModel.h>
 138 #include <SPlot2d_Histogram.h>
 139 #endif
 140
 141 // IDL includes
 142 #include <SALOMEconfig.h>
 143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
 144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
 145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
 146
 147 // Qt includes
 148 // #define       INCLUDE_MENUITEM_DEF // VSR commented ????????
 149 #include <QApplication>
 150 #include <QMenu>
 151 #include <QTextStream>
 152 #include <QListView>
 153 #include <QTreeView>
 154 #include <QCheckBox>
 155 #include <QLayout>
 156 #include <QDialogButtonBox>
 157
 158 // BOOST includes
 159 #include <boost/shared_ptr.hpp>
 160
 161 // VTK includes
 162 #include <vtkCallbackCommand.h>
 163 #include <vtkCamera.h>
 164 #include <vtkLookupTable.h>
 165 #include <vtkPlane.h>
 166 #include <vtkRenderer.h>
 167
 168 // SALOME KERNEL includes
 169 #include <SALOMEDSClient_ClientFactory.hxx>
 170 #include <SALOMEDSClient_IParameters.hxx>
 171 #include <SALOMEDSClient_SComponent.hxx>
 172 #include <SALOMEDSClient_StudyBuilder.hxx>
 173 #include <SALOMEDS_Study.hxx>
 174 #include <SALOMEDS_SObject.hxx>
 175 #include "utilities.h"
 176
 177 // OCCT includes
 178 #include <Standard_ErrorHandler.hxx>
 179 #include <NCollection_DataMap.hxx>
 180 #include <NCollection_DoubleMap.hxx>
 181
 182 #include <Basics_Utils.hxx>
 183
 184 // Below macro, when uncommented, switches on simplified (more performant) algorithm
 185 // of auto-color picking up
 186 #define SIMPLE_AUTOCOLOR
 187
 188 namespace
 189 {
 190   // Declarations
 191   //=============================================================
 192   void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
 193                             int                  theCommandID);
 194
 195   void ExportMeshToFile(int theCommandID);
 196
 197   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
 198
 199   void SetDisplayEntity(int theCommandID);
 200
 201   int  ActionToControl( int theID, bool theReversed = false );
 202
 203   void Control( int theCommandID );
 204
 205   // Definitions
 206   //================================================================================
 207   /*!
 208    * \brief Reads meshes from file
 209    */
 210   //================================================================================
 211
 212   void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
 213                              int                  theCommandID )
 214   {
 215     QStringList filter;
 216     std::string myExtension;
 217
 218     if ( theCommandID == SMESHOp::OpImportMED ) {
 219       filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
 220       filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
 221     }
 222     else if ( theCommandID == SMESHOp::OpImportUNV ) {
 223       filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
 224     }
 225     else if ( theCommandID == SMESHOp::OpImportDAT ) {
 226       filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
 227     }
 228     else if ( theCommandID == SMESHOp::OpImportSTL ) {
 229       filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
 230     }
 231   #ifdef WITH_CGNS
 232     else if ( theCommandID == SMESHOp::OpImportCGNS ) {
 233       filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 234     }
 235   #endif
 236     else if ( theCommandID == SMESHOp::OpImportSAUV ) {
 237       filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
 238       filter.append( QObject::tr( "All files (*)" ) );
 239     }
 240     else if ( theCommandID == SMESHOp::OpImportGMF ) {
 241       filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"  );
 242       filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
 243     }
 244
 245     QString anInitialPath = "";
 246     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 247       anInitialPath = QDir::currentPath();
 248
 249     QStringList filenames;
 250     bool toCreateGroups = true;
 251
 252     // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
 253     //   SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
 254     //     ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
 255     //   fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
 256     //   fd->setNameFilters( filter );
 257     //   fd->SetChecked( true );
 258     //   if ( fd->exec() )
 259     //     filenames << fd->selectedFile();
 260     //   toCreateGroups = fd->IsChecked();
 261
 262     //   delete fd;
 263     // }
 264     // else
 265     {
 266       filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
 267                                                   anInitialPath,
 268                                                   filter,
 269                                                   QObject::tr( "SMESH_IMPORT_MESH" ) );
 270     }
 271     if ( filenames.count() > 0 )
 272     {
 273       SUIT_OverrideCursor wc;
 274       _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
 275
 276       QStringList errors;
 277       QStringList anEntryList;
 278       bool isEmpty = false;
 279       for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
 280       {
 281         QString filename = *it;
 282         SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
 283         try {
 284           switch ( theCommandID ) {
 285           case SMESHOp::OpImportDAT:
 286             {
 287               // DAT format (currently unsupported)
 288               errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 289                              arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
 290               break;
 291             }
 292           case SMESHOp::OpImportUNV:
 293             {
 294               // UNV format
 295               aMeshes->length( 1 );
 296               aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
 297               if ( aMeshes[0]->_is_nil() )
 298                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 299                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 300               break;
 301             }
 302           case SMESHOp::OpImportMED:
 303             {
 304               // MED format
 305               SMESH::DriverMED_ReadStatus res;
 306               aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
 307               if ( res != SMESH::DRS_OK ) {
 308                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 309                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 310               }
 311               break;
 312             }
 313           case SMESHOp::OpImportSTL:
 314             {
 315               // STL format
 316               aMeshes->length( 1 );
 317               aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
 318               if ( aMeshes[0]->_is_nil() ) {
 319                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 320                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 321               }
 322               break;
 323             }
 324         #ifdef WITH_CGNS
 325           case SMESHOp::OpImportCGNS:
 326             {
 327               // CGNS format
 328               SMESH::DriverMED_ReadStatus res;
 329               aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
 330               if ( res != SMESH::DRS_OK ) {
 331                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 332                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 333               }
 334               break;
 335             }
 336         #endif
 337           case SMESHOp::OpImportSAUV:
 338             {
 339               // SAUV format
 340               SMESH::DriverMED_ReadStatus res;
 341               aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
 342               if ( res != SMESH::DRS_OK ) {
 343                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 344                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 345               }
 346               break;
 347             }
 348           case SMESHOp::OpImportGMF:
 349             {
 350               // GMF format
 351               SMESH::ComputeError_var res;
 352               aMeshes->length( 1 );
 353               aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
 354                                                                   toCreateGroups,
 355                                                                   res.out() );
 356               if ( res->code != SMESH::DRS_OK ) {
 357                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 358                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
 359                 if ( strlen( res->comment.in() ) > 0 ) {
 360                   errors.back() += ": ";
 361                   errors.back() += res->comment.in();
 362                 }
 363               }
 364               break;
 365             }
 366           }
 367         }
 368         catch ( const SALOME::SALOME_Exception& S_ex ) {
 369           errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 370                          arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 371         }
 372
 373         for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
 374         {
 375           _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
 376           if ( aMeshSO ) {
 377             _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
 378             _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
 379             aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
 380             if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
 381               SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
 382
 383             anEntryList.append( aMeshSO->GetID().c_str() );
 384           }
 385           else {
 386             isEmpty = true;
 387           }
 388         }
 389       }
 390
 391       // update Object browser
 392       SMESHGUI::GetSMESHGUI()->updateObjBrowser();
 393
 394       // browse to the published meshes
 395       if( LightApp_Application* anApp =
 396           dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
 397         anApp->browseObjects( anEntryList );
 398
 399       // show Error message box if there were errors
 400       if ( errors.count() > 0 ) {
 401         SUIT_MessageBox::critical( SMESHGUI::desktop(),
 402                                    QObject::tr( "SMESH_ERROR" ),
 403                                    QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
 404       }
 405
 406       // show warning message box, if some imported mesh is empty
 407       if ( isEmpty ) {
 408           SUIT_MessageBox::warning( SMESHGUI::desktop(),
 409                                     QObject::tr( "SMESH_WRN_WARNING" ),
 410                                     QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
 411       }
 412     }
 413   }
 414
 415   //================================================================================
 416   /*!
 417    * \brief Export selected meshes or groups into a file
 418    */
 419   //================================================================================
 420
 421   void ExportMeshToFile( int theCommandID )
 422   {
 423     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 424     SALOME_ListIO selected;
 425     if( aSel )
 426       aSel->selectedObjects( selected );
 427
 428     const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
 429                          theCommandID == SMESHOp::OpPopupExportDAT );
 430     const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
 431                          theCommandID == SMESHOp::OpPopupExportMED );
 432     const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
 433                          theCommandID == SMESHOp::OpPopupExportUNV );
 434     const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
 435                          theCommandID == SMESHOp::OpPopupExportSTL );
 436 #ifdef WITH_CGNS
 437     const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
 438                          theCommandID == SMESHOp::OpPopupExportCGNS );
 439 #else
 440     const bool isCGNS= false;
 441 #endif
 442     const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
 443                          theCommandID == SMESHOp::OpPopupExportSAUV );
 444     const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
 445                          theCommandID == SMESHOp::OpPopupExportGMF );
 446
 447     const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
 448     if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
 449       return;
 450     SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 451     bool aCheckWarn = true;
 452     if ( resMgr )
 453       aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
 454     // get mesh object from selection and check duplication of their names
 455     bool hasDuplicatedMeshNames = false;
 456     QList< QPair< SMESH::SMESH_IDSource_var, QString > >           aMeshList;
 457     QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
 458     SALOME_ListIteratorOfListIO It( selected );
 459     for( ; It.More(); It.Next() )
 460     {
 461       Handle(SALOME_InteractiveObject) anIObject = It.Value();
 462       SMESH::SMESH_IDSource_var aMeshItem =
 463         SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
 464       if ( aMeshItem->_is_nil() ) {
 465         SUIT_MessageBox::warning( SMESHGUI::desktop(),
 466                                   QObject::tr( "SMESH_WRN_WARNING" ),
 467                                   QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
 468         return;
 469       }
 470       SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
 471       if ( aCheckWarn && !aGroup->_is_nil() ) {
 472         QMessageBox msgBox(SUIT_MessageBox::Warning,QObject::tr("SMESH_WRN_WARNING"),
 473                             QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),QMessageBox::StandardButton::NoButton, SMESHGUI::desktop());
 474         QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
 475         msgBox.addButton(QMessageBox::Ok);
 476         msgBox.addButton(QMessageBox::Cancel);
 477         msgBox.setDefaultButton(QMessageBox::Cancel);
 478         QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
 479         QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
 480         lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
 481         lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
 482         if(msgBox.exec() == QMessageBox::Ok)
 483         {
 484             if(dontShowCheckBox.checkState() == Qt::Checked)
 485             {
 486               if ( resMgr )
 487                 resMgr->setValue( "SMESH", "show_warning", false);
 488             }
 489             aCheckWarn = false;
 490         }
 491         else
 492           return;
 493       }
 494
 495       QString aMeshName = anIObject->getName();
 496
 497       // check for name duplications
 498       if ( !hasDuplicatedMeshNames )
 499         for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 500           if( aMeshName == (*aMeshIter).second ) {
 501             hasDuplicatedMeshNames = true;
 502             break;
 503           }
 504         }
 505
 506       aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
 507     }
 508
 509     if( hasDuplicatedMeshNames && isMED ) {
 510       int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 511                                           QObject::tr("SMESH_WRN_WARNING"),
 512                                           QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
 513                                           QObject::tr("SMESH_BUT_YES"),
 514                                           QObject::tr("SMESH_BUT_NO"), 0, 1);
 515       if (aRet != 0)
 516         return;
 517     }
 518
 519     aMeshIter = aMeshList.begin();
 520     SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 521     SMESH::SMESH_Mesh_var            aMesh = aMeshOrGroup->GetMesh();
 522     QString                      aMeshName = (*aMeshIter).second;
 523
 524     if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
 525     {
 526       // check for equal group names within each mesh
 527       for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 528         SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 529         if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
 530           int aRet = SUIT_MessageBox::warning
 531             (SMESHGUI::desktop(),
 532              QObject::tr("SMESH_WRN_WARNING"),
 533              QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
 534              QObject::tr("SMESH_BUT_YES"),
 535              QObject::tr("SMESH_BUT_NO"), 0, 1);
 536           if (aRet != 0)
 537             return;
 538         }
 539       }
 540     }
 541
 542     // Warn the user about presence of not supported elements
 543     QString format;
 544     std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
 545     if ( isDAT )
 546     {
 547       format = "DAT";
 548       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 549       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 550     }
 551     else if ( isUNV )
 552     {
 553       format = "UNV";
 554       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 555       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 556       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 557       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
 558       notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
 559       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 560       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 561       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 562     }
 563     else if ( isSTL )
 564     {
 565       format = "STL";
 566       notSupportedElemTypes.push_back( SMESH::Entity_Edge );
 567       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
 568       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 569       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 570     }
 571     else if ( isCGNS )
 572     {
 573       format = "CGNS";
 574       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 575     }
 576     else if ( isSAUV )
 577     {
 578       format = "SAUV";
 579       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 580       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
 581       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
 582       notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
 583       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 584       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 585       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 586       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 587     }
 588     else if ( isGMF )
 589     {
 590       format = "GMF";
 591       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 592       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 593       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 594       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
 595       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
 596       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 597       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 598       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
 599       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 600     }
 601     if ( ! notSupportedElemTypes.empty() )
 602     {
 603       SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
 604       for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
 605         if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
 606           presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
 607     }
 608     if ( !presentNotSupported.empty() )
 609     {
 610       QString typeNames;
 611       const char* typeMsg[] = {
 612         "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
 613         "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
 614         "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
 615         "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
 616         "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
 617         "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
 618         "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
 619         "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
 620       };
 621       // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
 622       const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
 623       int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1];
 624
 625       QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
 626       for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
 627         typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
 628         if ( iType != presentNotSupported.size() - 1 )
 629           typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
 630       }
 631       int aRet = SUIT_MessageBox::warning
 632         (SMESHGUI::desktop(),
 633          QObject::tr("SMESH_WRN_WARNING"),
 634          QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
 635          QObject::tr("SMESH_BUT_YES"),
 636          QObject::tr("SMESH_BUT_NO"), 0, 1);
 637       if (aRet != 0)
 638         return;
 639     }
 640
 641     // Get parameters of export operation
 642
 643     QString            aFilename;
 644     SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
 645     // Init the parameters with the default values
 646     bool aIsASCII_STL   = true;
 647     bool toCreateGroups = false;
 648     if ( resMgr )
 649       toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
 650     bool toOverwrite  = true;
 651     bool toFindOutDim = true;
 652
 653     QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
 654     QString anInitialPath = "";
 655     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 656       anInitialPath = QDir::currentPath();
 657
 658     QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
 659
 660     // Get a file name to write in and additional otions
 661     if ( isUNV || isDAT || isGMF ) // Export w/o options
 662     {
 663       if ( isUNV )
 664         aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
 665       else if ( isDAT )
 666         aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
 667       else if ( isGMF )
 668         aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
 669           ";;" +  QObject::tr( "GMF_BINARY_FILES_FILTER" )  + " (*.meshb)";
 670      if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
 671       aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
 672                                             anInitialPath + QString("/") + aMeshName,
 673                                             aFilter, aTitle, false);
 674     }
 675     else if ( isCGNS )// Export to CGNS
 676     {
 677       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 678       fd->setWindowTitle( aTitle );
 679       fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 680       if ( !anInitialPath.isEmpty() )
 681         fd->setDirectory( anInitialPath );
 682       fd->selectFile(aMeshName);
 683       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 684       fd->setValidator( fv );
 685
 686       if ( fd->exec() )
 687         aFilename = fd->selectedFile();
 688       toOverwrite = fv->isOverwrite();
 689
 690       delete fd;
 691     }
 692     else if ( isSTL ) // Export to STL
 693     {
 694       QMap<QString, int> aFilterMap;
 695       aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
 696       aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" )   + " (*.stl)", 0 );
 697
 698       QStringList filters;
 699       QMap<QString, int>::const_iterator it = aFilterMap.begin();
 700       for ( ; it != aFilterMap.end(); ++it )
 701         filters.push_back( it.key() );
 702
 703       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 704       fd->setWindowTitle( aTitle );
 705       fd->setNameFilters( filters );
 706       fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
 707       if ( !anInitialPath.isEmpty() )
 708         fd->setDirectory( anInitialPath );
 709       fd->selectFile(aMeshName);
 710       bool is_ok = false;
 711       while (!is_ok) {
 712         if ( fd->exec() )
 713           aFilename = fd->selectedFile();
 714         aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
 715         is_ok = true;
 716       }
 717       delete fd;
 718     }
 719     else if ( isMED || isSAUV ) // Export to MED or SAUV
 720     {
 721       QMap<QString, SMESH::MED_VERSION> aFilterMap;
 722       //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
 723       if ( isMED ) {
 724         QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
 725         //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
 726         aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
 727       }
 728       else { // isSAUV
 729         aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
 730         aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
 731         aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
 732       }
 733
 734       QStringList filters;
 735       QString aDefaultFilter;
 736       QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
 737       for ( ; it != aFilterMap.end(); ++it ) {
 738         filters.push_back( it.key() );
 739         if (it.value() == SMESH::MED_V2_2)
 740           aDefaultFilter = it.key();
 741       }
 742       QStringList checkBoxes;
 743       checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
 744
 745       SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
 746       QList< QWidget* > wdgList;
 747       if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
 748         wdgList.append( fieldSelWdg );
 749
 750       SalomeApp_CheckFileDlg* fd =
 751         new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
 752       fd->setWindowTitle( aTitle );
 753       fd->setNameFilters( filters );
 754       fd->selectNameFilter( aDefaultFilter );
 755       fd->SetChecked( toCreateGroups, 0 );
 756       fd->SetChecked( toFindOutDim,   1 );
 757       if ( !anInitialPath.isEmpty() )
 758         fd->setDirectory( anInitialPath );
 759       fd->selectFile(aMeshName);
 760
 761
 762       QListView *lview = fd->findChild<QListView*>("listView");
 763       if( lview ) {
 764         lview->setMinimumHeight(200);
 765       }
 766       QTreeView *tview = fd->findChild<QTreeView*>("treeView");
 767       if( tview ) {
 768         tview->setMinimumHeight(200);
 769       }
 770
 771       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 772       fd->setValidator( fv );
 773
 774       bool is_ok = false;
 775       while (!is_ok) {
 776         if ( fd->exec() )
 777           aFilename = fd->selectedFile();
 778         else {
 779           aFilename = QString::null;
 780           break;
 781         }
 782         aFormat = aFilterMap[fd->selectedNameFilter()];
 783         toOverwrite = fv->isOverwrite();
 784         is_ok = true;
 785         if ( !aFilename.isEmpty() ) {
 786           // med-2.1 does not support poly elements
 787           if ( aFormat==SMESH::MED_V2_1 )
 788             for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 789               SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
 790               SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
 791               if ( nbElems[ SMESH::Entity_Polygon   ] + nbElems[ SMESH::Entity_Quad_Polygon   ] +
 792                    nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
 793               {
 794                 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 795                                                     QObject::tr("SMESH_WRN_WARNING"),
 796                                                     QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
 797                                                     QObject::tr("SMESH_BUT_YES"),
 798                                                     QObject::tr("SMESH_BUT_NO"), 0, 1);
 799                 if (aRet != 0) {
 800                   is_ok = false;
 801                   break;
 802                 }
 803               }
 804             }
 805           if( !toOverwrite ) {
 806             // can't append to an existing using other format
 807             SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
 808             bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
 809             if( !isVersionOk || aVersion != aFormat ) {
 810               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 811                                                   QObject::tr("SMESH_WRN_WARNING"),
 812                                                   QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
 813                                                   QObject::tr("SMESH_BUT_YES"),
 814                                                   QObject::tr("SMESH_BUT_NO"), 0, 1);
 815               if (aRet == 0)
 816                 toOverwrite = true;
 817               else
 818                 is_ok = false;
 819             }
 820
 821             QStringList aMeshNamesCollisionList;
 822             SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
 823             for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
 824               QString anExistingMeshName( aMeshNames[ i ] );
 825               for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 826                 QString anExportMeshName = (*aMeshIter).second;
 827                 if( anExportMeshName == anExistingMeshName ) {
 828                   aMeshNamesCollisionList.append( anExportMeshName );
 829                   break;
 830                 }
 831               }
 832             }
 833             if( !aMeshNamesCollisionList.isEmpty() ) {
 834               QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
 835               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 836                                                   QObject::tr("SMESH_WRN_WARNING"),
 837                                                   QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
 838                                                   QObject::tr("SMESH_BUT_YES"),
 839                                                   QObject::tr("SMESH_BUT_NO"),
 840                                                   QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
 841               if (aRet == 0)
 842                 toOverwrite = true;
 843               else if (aRet == 2)
 844                 is_ok = false;
 845             }
 846           }
 847         }
 848       }
 849       toCreateGroups = fd->IsChecked(0);
 850       toFindOutDim   = fd->IsChecked(1);
 851       fieldSelWdg->GetSelectedFeilds();
 852       if ( !fieldSelWdg->parent() )
 853         delete fieldSelWdg;
 854       delete fd;
 855     }
 856     else
 857     {
 858       return;
 859     }
 860
 861     // Perform export
 862
 863     if ( !aFilename.isEmpty() ) {
 864       // Check whether the file already exists and delete it if yes
 865       QFile aFile( aFilename );
 866       if ( aFile.exists() && toOverwrite )
 867         aFile.remove();
 868       SUIT_OverrideCursor wc;
 869
 870       try {
 871         // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
 872 //         bool Renumber = false;
 873 //         // PAL 14172  : Check of we have to renumber or not from the preferences before export
 874 //         if (resMgr)
 875 //           Renumber= resMgr->booleanValue("renumbering");
 876 //         if (Renumber){
 877 //           SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
 878 //           aMeshEditor->RenumberNodes();
 879 //           aMeshEditor->RenumberElements();
 880 //           if ( SMESHGUI::automaticUpdate() )
 881 //             SMESH::UpdateView();
 882 //         }
 883         if ( isMED )
 884         {
 885           aMeshIter = aMeshList.begin();
 886           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 887           {
 888             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 889             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 890             const GEOM::ListOfFields&       fields = aFieldList[ aMeshIndex ].first.in();
 891             const QString&            geoAssFields = aFieldList[ aMeshIndex ].second;
 892             const bool                   hasFields = ( fields.length() || !geoAssFields.isEmpty() );
 893             if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
 894               aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
 895                                        aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
 896             else
 897               aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
 898                                           aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
 899                                           fields, geoAssFields.toLatin1().data() );
 900           }
 901         }
 902         else if ( isSAUV )
 903         {
 904           for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
 905           {
 906             SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 907             if( !aMeshItem->_is_nil() )
 908               aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
 909           }
 910         }
 911         else if ( isDAT )
 912         {
 913           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 914             aMesh->ExportDAT( aFilename.toUtf8().data() );
 915           else
 916             aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
 917         }
 918         else if ( isUNV )
 919         {
 920           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 921             aMesh->ExportUNV( aFilename.toUtf8().data() );
 922           else
 923             aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
 924         }
 925         else if ( isSTL )
 926         {
 927           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 928             aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
 929           else
 930             aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
 931         }
 932         else if ( isCGNS )
 933         {
 934           aMeshIter = aMeshList.begin();
 935           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 936           {
 937             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 938             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 939             aMeshItem->ExportCGNS( aMeshOrGroup,
 940                                    aFilename.toUtf8().data(),
 941                                    toOverwrite && aMeshIndex == 0 );
 942           }
 943         }
 944         else if ( isGMF )
 945         {
 946           toCreateGroups = true;
 947           aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
 948         }
 949       }
 950       catch (const SALOME::SALOME_Exception& S_ex){
 951         wc.suspend();
 952         SUIT_MessageBox::warning(SMESHGUI::desktop(),
 953                                  QObject::tr("SMESH_WRN_WARNING"),
 954                                  QObject::tr("SMESH_EXPORT_FAILED"));
 955         wc.resume();
 956       }
 957     }
 958   }
 959
 960   inline void InverseEntityMode(unsigned int& theOutputMode,
 961                                 unsigned int  theMode)
 962   {
 963     bool anIsNotPresent = ~theOutputMode & theMode;
 964     if(anIsNotPresent)
 965       theOutputMode |= theMode;
 966     else
 967       theOutputMode &= ~theMode;
 968   }
 969
 970   void SetDisplayEntity(int theCommandID)
 971   {
 972     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 973     SALOME_ListIO selected;
 974     if ( aSel )
 975       aSel->selectedObjects( selected );
 976
 977     if ( selected.Extent() >= 1 ) {
 978       SUIT_OverrideCursor wc;
 979       SALOME_ListIteratorOfListIO It( selected );
 980       for( ; It.More(); It.Next()){
 981         Handle(SALOME_InteractiveObject) IObject = It.Value();
 982         if(IObject->hasEntry()){
 983           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
 984             unsigned int aMode = anActor->GetEntityMode();
 985             switch(theCommandID){
 986             case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
 987             case SMESHOp::OpDEEdges:      InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
 988             case SMESHOp::OpDEFaces:      InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
 989             case SMESHOp::OpDEVolumes:    InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
 990             case SMESHOp::OpDEBalls:      InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
 991             case SMESHOp::OpDEAllEntity:  aMode = SMESH_Actor::eAllEntity; break;
 992             }
 993             if(aMode)
 994               anActor->SetEntityMode(aMode);
 995           }
 996         }
 997       }
 998     }
 999   }
1000
1001   void AutoColor()
1002   {
1003     SalomeApp_Application* app =
1004       dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1005     if ( !app )
1006       return;
1007
1008     LightApp_SelectionMgr* aSel = app->selectionMgr();
1009     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1010     if ( !aSel || !appStudy )
1011       return;
1012
1013     SALOME_ListIO selected;
1014     aSel->selectedObjects( selected );
1015     if ( selected.IsEmpty() )
1016       return;
1017
1018     Handle(SALOME_InteractiveObject) anIObject = selected.First();
1019
1020     _PTR(Study)         aStudy = appStudy->studyDS();
1021     _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1022     SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1023     if ( aMainObject->_is_nil() )
1024       return;
1025
1026     SUIT_OverrideCursor wc;
1027
1028     aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1029
1030     QList<SALOMEDS::Color> aReservedColors;
1031
1032     SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1033     for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1034     {
1035       SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1036
1037 #ifdef SIMPLE_AUTOCOLOR   // simplified algorithm for auto-colors
1038       SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1039 #else                     // old algorithm  for auto-colors
1040       SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1041       aReservedColors.append( aColor );
1042 #endif                    // SIMPLE_AUTOCOLOR
1043       aGroupObject->SetColor( aColor );
1044
1045       _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1046       if ( aGroupSObject ) {
1047         QColor c;
1048         int delta;
1049         if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1050           switch ( aGroupObject->GetType ()) {
1051           case SMESH::NODE:
1052             anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1053           case SMESH::EDGE:
1054             anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1055           case SMESH::ELEM0D:
1056             anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1057           case SMESH::BALL:
1058             anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1059           case SMESH::VOLUME:
1060             SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1061             anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1062           case SMESH::FACE:
1063           default:
1064             SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1065             anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1066           }
1067         }
1068       }
1069     }
1070
1071     SMESH::RepaintCurrentView();
1072   }
1073
1074   void OverallMeshQuality()
1075   {
1076     SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1077     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1078     SALOME_ListIO selected;
1079     if( aSel )
1080       aSel->selectedObjects( selected );
1081
1082     if ( selected.IsEmpty() ) return;
1083     SALOME_ListIteratorOfListIO It( selected );
1084     for ( ; It.More(); It.Next() ) {
1085       SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1086       ctrlDlg->showInfo( It.Value() );
1087       ctrlDlg->show();
1088     }
1089   }
1090
1091   QString functorToString( SMESH::Controls::FunctorPtr f )
1092   {
1093     QString type = QObject::tr( "UNKNOWN_CONTROL" );
1094     if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1095       type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1096     else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1097       type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1098     else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1099       type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1100     else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1101       type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1102     else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1103       type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1104     else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1105       type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1106     else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1107       type = QObject::tr( "WARP_ELEMENTS" );
1108     else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1109       type = QObject::tr( "TAPER_ELEMENTS" );
1110     else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1111       type = QObject::tr( "SKEW_ELEMENTS" );
1112     else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1113       type = QObject::tr( "AREA_ELEMENTS" );
1114     else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1115       type = QObject::tr( "LENGTH_EDGES" );
1116     else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1117       type = QObject::tr( "LENGTH2D_EDGES" );
1118     else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1119       type = QObject::tr( "MULTI_BORDERS" );
1120     else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1121       type = QObject::tr( "MULTI2D_BORDERS" );
1122     else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1123       type = QObject::tr( "FREE_NODES" );
1124     else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1125       type = QObject::tr( "FREE_EDGES" );
1126     else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1127       type = QObject::tr( "FREE_BORDERS" );
1128     else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1129       type = QObject::tr( "FREE_FACES" );
1130     else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1131       type = QObject::tr( "BARE_BORDER_VOLUME" );
1132     else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1133       type = QObject::tr( "BARE_BORDER_FACE" );
1134     else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1135       type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1136     else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1137       type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1138     else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1139       type = QObject::tr( "EQUAL_NODE" );
1140     else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1141       type = QObject::tr( "EQUAL_EDGE" );
1142     else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1143       type = QObject::tr( "EQUAL_FACE" );
1144     else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1145       type = QObject::tr( "EQUAL_VOLUME" );
1146     else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1147       type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1148     return type;
1149   }
1150
1151   void SaveDistribution()
1152   {
1153     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1154     SALOME_ListIO selected;
1155     if ( aSel )
1156       aSel->selectedObjects( selected );
1157
1158     if ( selected.Extent() == 1 ) {
1159       Handle(SALOME_InteractiveObject) anIO = selected.First();
1160       if ( anIO->hasEntry() ) {
1161         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1162         if ( anActor &&
1163              anActor->GetScalarBarActor() &&
1164              anActor->GetControlMode() != SMESH_Actor::eNone )
1165         {
1166           SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1167           SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1168           if ( aScalarBarActor && aFunctor ) {
1169             SMESH::Controls::NumericalFunctor* aNumFun =
1170               dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1171             if ( aNumFun ) {
1172               std::vector<int> elements;
1173               SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1174               if ( mesh->_is_nil() ) {
1175                 SMESH::SMESH_IDSource_var idSource =
1176                   SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1177                 if ( !idSource->_is_nil() )
1178                 {
1179                   SMESH::long_array_var ids = idSource->GetIDs();
1180                   elements.resize( ids->length() );
1181                   for ( unsigned i = 0; i < elements.size(); ++i )
1182                     elements[i] = ids[i];
1183                 }
1184               }
1185               int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1186               vtkLookupTable* lookupTable =
1187                 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1188               double * minmax = lookupTable->GetRange();
1189               bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1190               std::vector<int>    nbEvents;
1191               std::vector<double> funValues;
1192               aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1193                                      elements, minmax, isLogarithmic );
1194               QString anInitialPath = "";
1195               if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1196                 anInitialPath = QDir::currentPath();
1197               QString aMeshName = anIO->getName();
1198               QStringList filter;
1199               filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1200               filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1201               QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1202                 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1203               aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1204                                                      aFilename,
1205                                                      filter,
1206                                                      QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1207                                                      false );
1208               if ( !aFilename.isEmpty() ) {
1209                 QFile f( aFilename );
1210                 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1211                   QTextStream out( &f );
1212                   out << "# Mesh: " << aMeshName << endl;
1213                   out << "# Control: " << functorToString( aFunctor ) << endl;
1214                   out << "#" << endl;
1215                   out.setFieldWidth( 10 );
1216                   for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1217                     out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1218                   f.close();
1219                 }
1220               }
1221             }
1222           }
1223         }
1224       }
1225     }
1226   }
1227
1228   void ShowElement( int theCommandID )
1229   {
1230     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1231     SALOME_ListIO selected;
1232     if ( aSel )
1233       aSel->selectedObjects( selected );
1234
1235     if ( selected.Extent() == 1 ) {
1236       Handle(SALOME_InteractiveObject) anIO = selected.First();
1237       if ( anIO->hasEntry() ) {
1238         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1239         if ( anActor &&
1240              anActor->GetScalarBarActor() &&
1241              anActor->GetControlMode() != SMESH_Actor::eNone )
1242         {
1243           SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1244           if ( theCommandID == SMESHOp::OpShowDistribution ) {
1245             aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1246           }
1247           else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1248             aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1249           }
1250         }
1251       }
1252     }
1253   }
1254
1255 #ifndef DISABLE_PLOT2DVIEWER
1256   void PlotDistribution()
1257   {
1258     SalomeApp_Application* app =
1259       dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1260     if( !app )
1261       return;
1262
1263     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1264     SALOME_ListIO selected;
1265     if ( aSel )
1266       aSel->selectedObjects( selected );
1267
1268     if ( selected.Extent() == 1 ) {
1269       Handle(SALOME_InteractiveObject) anIO = selected.First();
1270       if ( anIO->hasEntry() ) {
1271         //Find Actor by entry before getting Plot2d viewer,
1272         //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1273         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1274
1275         SUIT_ViewManager* aViewManager =
1276           app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1277         if( !aViewManager )
1278           return;
1279
1280         SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1281         if ( !aView )
1282           return;
1283
1284         Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1285         if ( !aPlot )
1286           return;
1287
1288         if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1289         {
1290           SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1291           QString functorName = functorToString( anActor->GetFunctor());
1292           QString aHistogramName("%1 : %2");
1293           aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1294           aHistogram->setName(aHistogramName);
1295           aHistogram->setHorTitle(functorName);
1296           aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1297           aPlot->displayObject(aHistogram, true);
1298         }
1299       }
1300     }
1301   }
1302 #endif //DISABLE_PLOT2DVIEWER
1303
1304   void DisableAutoColor()
1305   {
1306     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1307     SALOME_ListIO selected;
1308     if ( aSel )
1309       aSel->selectedObjects( selected );
1310
1311     if ( selected.Extent() ) {
1312       Handle(SALOME_InteractiveObject) anIObject = selected.First();
1313       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1314       if ( !aMesh->_is_nil() ) {
1315         aMesh->SetAutoColor( false );
1316       }
1317     }
1318   }
1319
1320   void sortChildren()
1321   {
1322     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1323     SALOME_ListIO selected;
1324     if ( aSel ) {
1325       aSel->selectedObjects( selected );
1326       if ( selected.Extent() )
1327       {
1328         Handle(SALOME_InteractiveObject) anIObject = selected.First();
1329         _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1330         _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1331         if (aSObj) {
1332           if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1333             SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1334           }
1335         }
1336       }
1337     }
1338   }
1339
1340   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1341   {
1342     SALOME_ListIO selected;
1343     SalomeApp_Application* app =
1344       dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1345     if ( !app )
1346       return;
1347
1348     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1349     SalomeApp_Study*   appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1350     if ( !aSel || !appStudy )
1351       return;
1352
1353     if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1354       if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1355         aModule->EmitSignalDeactivateDialog();
1356         if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1357           (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1358       }
1359       return;
1360     }
1361
1362     _PTR(Study) aStudy = appStudy->studyDS();
1363
1364     aSel->selectedObjects( selected );
1365
1366     if ( selected.Extent() >= 1 )
1367     {
1368       switch ( theCommandID ) {
1369       case SMESHOp::OpTransparency:
1370       {
1371         SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1372         (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1373         return;
1374       }
1375       case SMESHOp::OpProperties:
1376       {
1377         double color[3];
1378         QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1379         QColor orientationColor, outlineColor, volumeColor;
1380         int deltaF = 0, deltaV = 0;
1381         int elem0dSize   = 1;
1382         //int ballSize     = 1;
1383         double ballScale = 1.0;
1384         int edgeWidth    = 1;
1385         int outlineWidth = 1;
1386         double shrinkCoef = 0.0;
1387         double orientationScale = 0.0;
1388         bool orientation3d = false;
1389         VTK::MarkerType markerType = VTK::MT_NONE;
1390         VTK::MarkerScale markerScale = VTK::MS_NONE;
1391         int markerId = 0;
1392         bool hasNodes = false;
1393         int presentEntities = 0;
1394         bool firstTime  = true;
1395
1396         SALOME_ListIteratorOfListIO It( selected );
1397         for ( ; It.More(); It.Next() ) {
1398           Handle(SALOME_InteractiveObject) IObject = It.Value();
1399           if ( !IObject->hasEntry() ) continue;
1400           SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1401           if ( !anActor || !anActor->GetObject() ) continue;
1402
1403           if ( firstTime ) {
1404             // nodes: color, marker
1405             anActor->GetNodeColor( color[0], color[1], color[2] );
1406             nodeColor.setRgbF( color[0], color[1], color[2] );
1407             markerType  = anActor->GetMarkerType();
1408             markerScale = anActor->GetMarkerScale();
1409             markerId    = anActor->GetMarkerTexture();
1410             // edges: color, width
1411             anActor->GetEdgeColor( color[0], color[1], color[2] );
1412             edgeColor.setRgbF( color[0], color[1], color[2] );
1413             edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1414             // faces: front color, back color (delta)
1415             anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1416             faceColor.setRgbF( color[0], color[1], color[2] );
1417             // faces: front color, back color (delta)
1418             anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1419             volumeColor.setRgbF( color[0], color[1], color[2] );
1420             // 0d elements: color, size
1421             anActor->Get0DColor( color[0], color[1], color[2] );
1422             elem0dColor.setRgbF( color[0], color[1], color[2] );
1423             elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1424             // balls: color, size
1425             anActor->GetBallColor( color[0], color[1], color[2] );
1426             ballColor.setRgbF( color[0], color[1], color[2] );
1427             //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1428             ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1429             // outlines: color
1430             anActor->GetOutlineColor( color[0], color[1], color[2] );
1431             outlineColor.setRgbF( color[0], color[1], color[2] );
1432             outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1433             // orientation vectors: color, scale, 3d flag
1434             anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1435             orientationColor.setRgbF( color[0], color[1], color[2] );
1436             orientationScale = anActor->GetFacesOrientationScale();
1437             orientation3d = anActor->GetFacesOrientation3DVectors();
1438             // shrink factor
1439             shrinkCoef = anActor->GetShrinkFactor();
1440           }
1441
1442           firstTime = false; // we only take properties from first object (for performance reasons)
1443
1444           if ( !hasNodes )
1445             hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1446           if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1447             presentEntities = presentEntities | SMESH_Actor::eEdges;
1448           if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1449             presentEntities = presentEntities | SMESH_Actor::eFaces;
1450           if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1451             presentEntities = presentEntities | SMESH_Actor::eVolumes;
1452           if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1453             presentEntities = presentEntities | SMESH_Actor::e0DElements;
1454           if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1455             presentEntities = presentEntities | SMESH_Actor::eBallElem;
1456
1457           // as we know that all types of elements are present, we can exit the loop
1458           if ( presentEntities == SMESH_Actor::eAllEntity )
1459             break;
1460         }
1461
1462         SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1463         // nodes: color, marker
1464         dlg.setNodeColor( nodeColor );
1465         if( markerType != VTK::MT_USER )
1466           dlg.setNodeMarker( markerType, markerScale );
1467         else
1468           dlg.setNodeCustomMarker( markerId );
1469         // edges: color, line width
1470         dlg.setEdgeColor( edgeColor );
1471         dlg.setEdgeWidth( edgeWidth );
1472         // faces: front color, back color
1473         dlg.setFaceColor( faceColor, deltaF );
1474         // volumes: normal color, reversed color
1475         dlg.setVolumeColor( volumeColor, deltaV );
1476         // outlines: color, line width
1477         dlg.setOutlineColor( outlineColor );
1478         dlg.setOutlineWidth( outlineWidth );
1479         // 0d elements: color, size
1480         dlg.setElem0dColor( elem0dColor );
1481         dlg.setElem0dSize( elem0dSize );
1482         // balls: color, size
1483         dlg.setBallColor( ballColor );
1484         //dlg.setBallSize( ballSize );
1485         dlg.setBallScale( ballScale );
1486         // orientation: color, scale, 3d flag
1487         dlg.setOrientationColor( orientationColor );
1488         dlg.setOrientationSize( int( orientationScale * 100. ) );
1489         dlg.setOrientation3d( orientation3d );
1490         // shrink: scale factor
1491         dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1492         // hide unused controls
1493         dlg.showControls( presentEntities, hasNodes );
1494
1495         if ( dlg.exec() ) {
1496           nodeColor        = dlg.nodeColor();
1497           markerType       = dlg.nodeMarkerType();
1498           markerScale      = dlg.nodeMarkerScale();
1499           markerId         = dlg.nodeMarkerId();
1500           edgeColor        = dlg.edgeColor();
1501           edgeWidth        = dlg.edgeWidth();
1502           faceColor        = dlg.faceColor();
1503           deltaF           = dlg.faceColorDelta();
1504           volumeColor      = dlg.volumeColor();
1505           deltaV           = dlg.volumeColorDelta();
1506           outlineColor     = dlg.outlineColor();
1507           outlineWidth     = dlg.outlineWidth();
1508           elem0dColor      = dlg.elem0dColor();
1509           elem0dSize       = dlg.elem0dSize();
1510           ballColor        = dlg.ballColor();
1511          // ballSize         = dlg.ballSize();
1512           ballScale        = dlg.ballScale();
1513           orientationColor = dlg.orientationColor();
1514           orientationScale = dlg.orientationSize() / 100.;
1515           orientation3d    = dlg.orientation3d();
1516           shrinkCoef       = dlg.shrinkCoef() / 100.;
1517
1518           // store point markers map that might be changed by the user
1519           theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1520
1521           // set properties from dialog box to the presentations
1522           SALOME_ListIteratorOfListIO It( selected );
1523           for ( ; It.More(); It.Next() ) {
1524             Handle(SALOME_InteractiveObject) IObject = It.Value();
1525             if ( !IObject->hasEntry() ) continue;
1526             SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1527             if ( !anActor ) continue;
1528
1529             // nodes: color, marker
1530             anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1531             if ( markerType != VTK::MT_USER ) {
1532               anActor->SetMarkerStd( markerType, markerScale );
1533             }
1534             else {
1535               const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1536               VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1537               if ( iter != markerMap.end() )
1538                 anActor->SetMarkerTexture( markerId, iter->second.second );
1539             }
1540             // volumes: normal color, reversed color (delta)
1541             anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1542             // faces: front color, back color (delta)
1543             anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1544             // edges: color, width
1545             anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1546             anActor->SetLineWidth( edgeWidth );
1547             // outlines: color
1548             anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1549             anActor->SetOutlineWidth( outlineWidth );
1550             // 0D elements: color, size
1551             anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1552             anActor->Set0DSize( elem0dSize );
1553             // balls: color, size
1554             anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1555             // anActor->SetBallSize( ballSize );
1556             anActor->SetBallScale( ballScale );
1557             // orientation: color, scale, 3d flag
1558             anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1559             anActor->SetFacesOrientationScale( orientationScale );
1560             anActor->SetFacesOrientation3DVectors( orientation3d );
1561             // shrink factor
1562             anActor->SetShrinkFactor( shrinkCoef );
1563
1564             // for groups, set also proper color
1565             SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1566             if ( !aGroupObject->_is_nil() ) {
1567               SMESH::ElementType anElementType = aGroupObject->GetType();
1568               QColor aColor;
1569               switch( anElementType ) {
1570               case SMESH::NODE:
1571                 aColor = nodeColor; break;
1572               case SMESH::EDGE:
1573                 aColor = edgeColor; break;
1574               case SMESH::FACE:
1575                 aColor = faceColor; break;
1576               case SMESH::VOLUME:
1577                 aColor = volumeColor; break;
1578               case SMESH::ELEM0D:
1579                 aColor = elem0dColor; break;
1580               case SMESH::BALL:
1581                 aColor = ballColor; break;
1582               default: break;
1583               }
1584
1585               if ( aColor.isValid() ) {
1586                 SALOMEDS::Color aGroupColor;
1587                 aGroupColor.R = aColor.redF();
1588                 aGroupColor.G = aColor.greenF();
1589                 aGroupColor.B = aColor.blueF();
1590                 aGroupObject->SetColor( aGroupColor );
1591               }
1592             } // if ( !aGroupObject->_is_nil() )
1593           } // for ( ; It.More(); It.Next() )
1594           SMESH::RepaintCurrentView();
1595         } // if ( dlg.exec() )
1596         return;
1597       } // case SMESHOp::OpProperties:
1598       } // switch(theCommandID)
1599       SUIT_OverrideCursor wc;
1600       SALOME_ListIteratorOfListIO It( selected );
1601       for( ; It.More(); It.Next()){
1602         Handle(SALOME_InteractiveObject) IObject = It.Value();
1603         if(IObject->hasEntry()){
1604           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1605             switch(theCommandID){
1606             case SMESHOp::OpDMWireframe:
1607               anActor->SetRepresentation(SMESH_Actor::eEdge);
1608               break;
1609             case SMESHOp::OpDMShading:
1610               anActor->SetRepresentation(SMESH_Actor::eSurface);
1611               break;
1612             case SMESHOp::OpDMShrink:
1613               if(anActor->IsShrunk())
1614                 anActor->UnShrink();
1615               else
1616                 anActor->SetShrink();
1617               break;
1618             case SMESHOp::OpDMNodes:
1619               anActor->SetRepresentation(SMESH_Actor::ePoint);
1620               break;
1621             case SMESHOp::OpRepresentationLines:
1622               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1623                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1624               break;
1625             case SMESHOp::OpRepresentationArcs:
1626               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1627                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1628               break;
1629             }
1630           }
1631         }
1632       }
1633       SMESH::RepaintCurrentView();
1634     }
1635   }
1636
1637   int ActionToControl( int theID, bool theReversed )
1638   {
1639     NCollection_DoubleMap<int,int> ActionControl;
1640     ActionControl.Bind( 0,                                SMESH_Actor::eNone );
1641     ActionControl.Bind( SMESHOp::OpFreeNode,              SMESH_Actor::eFreeNodes );
1642     ActionControl.Bind( SMESHOp::OpEqualNode,             SMESH_Actor::eCoincidentNodes );
1643     ActionControl.Bind( SMESHOp::OpNodeConnectivityNb,    SMESH_Actor::eNodeConnectivityNb );
1644     ActionControl.Bind( SMESHOp::OpFreeEdge,              SMESH_Actor::eFreeEdges );
1645     ActionControl.Bind( SMESHOp::OpFreeBorder,            SMESH_Actor::eFreeBorders );
1646     ActionControl.Bind( SMESHOp::OpLength,                SMESH_Actor::eLength );
1647     ActionControl.Bind( SMESHOp::OpConnection,            SMESH_Actor::eMultiConnection );
1648     ActionControl.Bind( SMESHOp::OpEqualEdge,             SMESH_Actor::eCoincidentElems1D );
1649     ActionControl.Bind( SMESHOp::OpFreeFace,              SMESH_Actor::eFreeFaces );
1650     ActionControl.Bind( SMESHOp::OpBareBorderFace,        SMESH_Actor::eBareBorderFace );
1651     ActionControl.Bind( SMESHOp::OpOverConstrainedFace,   SMESH_Actor::eOverConstrainedFace );
1652     ActionControl.Bind( SMESHOp::OpLength2D,              SMESH_Actor::eLength2D );
1653     ActionControl.Bind( SMESHOp::OpConnection2D,          SMESH_Actor::eMultiConnection2D );
1654     ActionControl.Bind( SMESHOp::OpArea,                  SMESH_Actor::eArea );
1655     ActionControl.Bind( SMESHOp::OpTaper,                 SMESH_Actor::eTaper );
1656     ActionControl.Bind( SMESHOp::OpAspectRatio,           SMESH_Actor::eAspectRatio );
1657     ActionControl.Bind( SMESHOp::OpMinimumAngle,          SMESH_Actor::eMinimumAngle );
1658     ActionControl.Bind( SMESHOp::OpWarpingAngle,          SMESH_Actor::eWarping );
1659     ActionControl.Bind( SMESHOp::OpSkew,                  SMESH_Actor::eSkew );
1660     ActionControl.Bind( SMESHOp::OpMaxElementLength2D,    SMESH_Actor::eMaxElementLength2D );
1661     ActionControl.Bind( SMESHOp::OpEqualFace,             SMESH_Actor::eCoincidentElems2D );
1662     ActionControl.Bind( SMESHOp::OpAspectRatio3D,         SMESH_Actor::eAspectRatio3D );
1663     ActionControl.Bind( SMESHOp::OpVolume,                SMESH_Actor::eVolume3D );
1664     ActionControl.Bind( SMESHOp::OpMaxElementLength3D,    SMESH_Actor::eMaxElementLength3D );
1665     ActionControl.Bind( SMESHOp::OpBareBorderVolume,      SMESH_Actor::eBareBorderVolume );
1666     ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1667     ActionControl.Bind( SMESHOp::OpEqualVolume,           SMESH_Actor::eCoincidentElems3D );
1668
1669     return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1670   }
1671
1672   void Control( int theCommandID )
1673   {
1674     SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1675     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1676
1677     SALOME_ListIO selected;
1678     if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1679       aSel->selectedObjects( selected );
1680
1681     if ( !selected.IsEmpty() ) {
1682       SALOME_ListIteratorOfListIO It(selected);
1683       for ( ; It.More(); It.Next())
1684       {
1685         Handle(SALOME_InteractiveObject) anIO = It.Value();
1686         if ( !anIO.IsNull() ) {
1687           _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1688           if ( SO ) {
1689             CORBA::Object_var         aObject = SMESH::SObjectToObject( SO );
1690             SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1691             if ( !anIDSrc->_is_nil() ) {
1692               SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1693               if (( !anActor && selected.Extent() == 1 ) &&
1694                   ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1695               {
1696                 anActor->SetControlMode( aControl );
1697                 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1698                 SMESH::UpdateView  ( SMESH::eDisplay, anIO->getEntry() );
1699               }
1700               if ( anActor )
1701               {
1702                 if ( anActor->GetControlMode() != aControl )
1703                   anActor->SetControlMode( aControl );
1704                 QString functorName = functorToString( anActor->GetFunctor() );
1705                 int anEntitiesCount = anActor->GetNumberControlEntities();
1706                 if (anEntitiesCount >= 0)
1707                   functorName = functorName + ": " + QString::number(anEntitiesCount);
1708                 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1709                 SMESH::RepaintCurrentView();
1710 #ifndef DISABLE_PLOT2DVIEWER
1711                 if ( anActor->GetPlot2Histogram() ) {
1712                   SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1713                   QString aHistogramName("%1 : %2");
1714                   aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1715                   aHistogram->setName( aHistogramName );
1716                   aHistogram->setHorTitle( functorName );
1717                   SMESH::ProcessIn2DViewers( anActor );
1718                 }
1719 #endif
1720               }
1721             }
1722           }
1723         }
1724       }
1725     }
1726   }
1727
1728
1729   bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1730                    SMESH::MeshObjectType                    theType,
1731                    const QString                            theInTypeName,
1732                    QString &                                theOutTypeName)
1733   {
1734     SMESH_TypeFilter aTypeFilter( theType );
1735     QString entry;
1736     if ( !theIO.IsNull() )
1737     {
1738       entry = theIO->getEntry();
1739       LightApp_DataOwner owner( entry );
1740       if ( aTypeFilter.isOk( &owner )) {
1741         theOutTypeName = theInTypeName;
1742         return true;
1743       }
1744     }
1745     return false;
1746   }
1747
1748
1749   QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1750   {
1751     _PTR(Study)  aStudy = SMESH::GetActiveStudyDocument();
1752     _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1753     if (aSObj) {
1754       _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1755       CORBA::String_var  anID = aSComp->GetID().c_str();
1756       if ( !strcmp(anID.in(),theIO->getEntry()) )
1757         return "Component";
1758     }
1759
1760     QString aTypeName;
1761     if (
1762         CheckOIType ( theIO, SMESH::HYPOTHESIS,    "Hypothesis", aTypeName ) ||
1763         CheckOIType ( theIO, SMESH::ALGORITHM,     "Algorithm",  aTypeName ) ||
1764         CheckOIType ( theIO, SMESH::MESH,          "Mesh",       aTypeName ) ||
1765         CheckOIType ( theIO, SMESH::SUBMESH,       "SubMesh",    aTypeName ) ||
1766         CheckOIType ( theIO, SMESH::GROUP,         "Group",      aTypeName )
1767         )
1768       return aTypeName;
1769
1770     return "NoType";
1771   }
1772
1773
1774   // QString CheckHomogeneousSelection()
1775   // {
1776   //   LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1777   //   SALOME_ListIO selected;
1778   //   if ( aSel )
1779   //     aSel->selectedObjects( selected );
1780
1781   //   QString RefType = CheckTypeObject(selected.First());
1782   //   SALOME_ListIteratorOfListIO It(selected);
1783   //   for ( ; It.More(); It.Next())
1784   //   {
1785   //     Handle(SALOME_InteractiveObject) IObject = It.Value();
1786   //     QString Type = CheckTypeObject(IObject);
1787   //     if ( Type.compare(RefType) != 0 )
1788   //       return "Heterogeneous Selection";
1789   //   }
1790
1791   //   return RefType;
1792   // }
1793
1794   uint randomize( uint size )
1795   {
1796     static bool initialized = false;
1797     if ( !initialized ) {
1798       qsrand( QDateTime::currentDateTime().toTime_t() );
1799       initialized = true;
1800     }
1801     uint v = qrand();
1802     v = uint( (double)( v ) / RAND_MAX * size );
1803     v = qMax( uint(0), qMin ( v, size-1 ) );
1804     return v;
1805   }
1806
1807 } //namespace
1808
1809 void SMESHGUI::OnEditDelete()
1810 {
1811   // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1812   LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1813   SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1814
1815   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1816   _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1817   _PTR(GenericAttribute) anAttr;
1818   _PTR(AttributeIOR) anIOR;
1819
1820   int objectCount = 0;
1821   QString aNameList;
1822   QString aParentComponent = QString::null;
1823   Handle(SALOME_InteractiveObject) anIO;
1824   for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1825   {
1826     anIO = anIt.Value();
1827     QString cur = anIO->getComponentDataType();
1828     _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1829     if (aSO) {
1830       // check if object is reference
1831       _PTR(SObject) aRefSObj;
1832       aNameList.append("\n    - ");
1833       if ( aSO->ReferencedObject( aRefSObj ) ) {
1834         QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1835         aNameList.append( aRefName );
1836         cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1837       }
1838       else
1839         aNameList.append(anIO->getName());
1840       objectCount++;
1841     }
1842
1843     if( aParentComponent.isNull() )
1844       aParentComponent = cur;
1845     else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1846       aParentComponent = "";
1847   }
1848
1849   if ( objectCount == 0 )
1850     return; // No Valid Objects Selected
1851
1852   if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() )  {
1853     SUIT_MessageBox::warning( SMESHGUI::desktop(),
1854                               QObject::tr("ERR_ERROR"),
1855                               QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1856     return;
1857   }
1858   // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1859   if (SUIT_MessageBox::warning
1860       (SMESHGUI::desktop(),
1861        QObject::tr("SMESH_WRN_WARNING"),
1862        QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1863        SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1864        SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1865     return;
1866
1867   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1868
1869   // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1870   // then treat them all starting from the deepest objects (at list back)
1871   std::list< _PTR(SObject) > listSO;
1872   SALOME_ListIteratorOfListIO It(selected);
1873   for( ; It.More(); It.Next()) // loop on selected IO's
1874   {
1875     Handle(SALOME_InteractiveObject) IObject = It.Value();
1876     if(IObject->hasEntry()) {
1877       _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1878
1879       // disable removal of "SMESH" component object
1880       if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1881         anIOR = anAttr;
1882         if ( engineIOR() == anIOR->Value().c_str() )
1883           continue;
1884       }
1885       //Check the referenced object
1886       _PTR(SObject) aRefSObject;
1887       if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1888         aSO = aRefSObject; // Delete main Object instead of reference
1889
1890       listSO.push_back( aSO );
1891       std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1892       for ( ; itSO != listSO.end(); ++itSO ) {
1893         _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1894         for (it->InitEx(false); it->More(); it->Next())
1895           listSO.push_back( it->Value() );
1896       }
1897     }
1898   }
1899   // Check if none of objects to delete is referred from outside
1900   std::list< _PTR(SObject) >::reverse_iterator ritSO;
1901   for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1902   {
1903     _PTR(SObject) SO = *ritSO;
1904     if ( !SO ) continue;
1905     std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO  );
1906     for (size_t i = 0; i < aReferences.size(); i++) {
1907       _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1908       std::string type = aComponent->ComponentDataType();
1909       if ( type != "SMESH" )
1910       {
1911         SUIT_MessageBox::warning( anApp->desktop(),
1912                                   QObject::tr("WRN_WARNING"),
1913                                   QObject::tr("DEP_OBJECT") );
1914         return; // outside SMESH, there is an object depending on a SMESH object
1915       }
1916     }
1917   }
1918
1919   // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1920   for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1921   {
1922     Handle(SALOME_InteractiveObject) IObject = It.Value();
1923     SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1924     if ( !mesh->_is_nil() )
1925       mesh->Clear();
1926   }
1927
1928   // Treat SO's in the list starting from the back
1929   aStudyBuilder->NewCommand();  // There is a transaction
1930   for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1931   {
1932     _PTR(SObject) SO = *ritSO;
1933     if ( !SO ) continue;
1934     std::string anEntry = SO->GetID();
1935
1936     /** Erase graphical object and remove all its data **/
1937     if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1938       SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1939     }
1940     /** Remove an object from data structures **/
1941     SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1942     SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1943     if ( !aGroup->_is_nil() ) {                          // DELETE GROUP
1944       SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1945       aMesh->RemoveGroup( aGroup );
1946     }
1947     else if ( !aSubMesh->_is_nil() ) {                   // DELETE SUBMESH
1948       SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1949       aMesh->RemoveSubMesh( aSubMesh );
1950
1951       _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1952       if (aMeshSO)
1953         SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1954     }
1955     else {
1956       Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1957         ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1958       QString objType = CheckTypeObject(IObject);
1959       if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1960         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1961         aStudyBuilder->RemoveObjectWithChildren( SO );
1962       }
1963       else {// default action: remove SObject from the study
1964         // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1965         //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1966         //op->start();
1967         aStudyBuilder->RemoveObjectWithChildren( SO );
1968         //op->finish();
1969       }
1970     }
1971   } /* listSO back loop */
1972
1973   aStudyBuilder->CommitCommand();
1974
1975   /* Clear any previous selection */
1976   SALOME_ListIO l1;
1977   aSel->setSelectedObjects( l1 );
1978
1979   SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1980 }
1981
1982 extern "C" {
1983   SMESHGUI_EXPORT CAM_Module* createModule()
1984   {
1985     return new SMESHGUI();
1986   }
1987
1988   SMESHGUI_EXPORT  char* getModuleVersion() {
1989     return (char*)SMESH_VERSION_STR;
1990   }
1991 }
1992
1993 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1994
1995 //=============================================================================
1996 /*!
1997  *
1998  */
1999 //=============================================================================
2000 SMESHGUI::SMESHGUI() :
2001 SalomeApp_Module( "SMESH" )
2002 {
2003   if ( CORBA::is_nil( myComponentSMESH ) )
2004   {
2005     CORBA::Boolean anIsEmbeddedMode;
2006     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2007     //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2008
2009     //  0019923: EDF 765 SMESH : default values of hypothesis
2010     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2011     int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2012     myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2013     nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2014     myComponentSMESH->SetDefaultNbSegments( nbSeg );
2015
2016     const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2017     for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2018       if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2019       {
2020         QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2021         myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2022       }
2023   }
2024
2025   myActiveDialogBox = 0;
2026   myFilterLibraryDlg = 0;
2027   myState = -1;
2028   myDisplayer = 0;
2029
2030   myEventCallbackCommand = vtkCallbackCommand::New();
2031   myEventCallbackCommand->Delete();
2032   myEventCallbackCommand->SetClientData( this );
2033   myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2034   myPriority = 0.0;
2035
2036   /* load resources for all available meshers */
2037   SMESH::InitAvailableHypotheses();
2038 }
2039
2040 //=============================================================================
2041 /*!
2042  *
2043  */
2044 //=============================================================================
2045 SMESHGUI::~SMESHGUI()
2046 {
2047 }
2048
2049 //=============================================================================
2050 /*!
2051  *
2052  */
2053 //=============================================================================
2054 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2055 {
2056   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2057   if( anApp )
2058     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2059   else
2060     return 0;
2061 }
2062
2063 //=============================================================================
2064 /*!
2065  *
2066  */
2067 //=============================================================================
2068 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2069 {
2070   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2071   if ( !resMgr )
2072     return false;
2073
2074   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
2075   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2076   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2077   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2078   return autoUpdate && !exceeded;
2079 }
2080
2081 //=============================================================================
2082 /*!
2083  *
2084  */
2085 //=============================================================================
2086 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2087                                 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2088 {
2089   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2090   if ( !resMgr )
2091     return false;
2092
2093   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update", false );
2094   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2095   bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2096
2097   SMESH::long_array_var info = theMesh->GetMeshInfo();
2098   long nbOdElems = info[SMDSEntity_0D];
2099   long nbEdges   = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2100   long nbFaces   = info[SMDSEntity_Triangle]   + info[SMDSEntity_Quad_Triangle]   + info[SMDSEntity_BiQuad_Triangle] +
2101                    info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2102                    info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2103   long nbVolumes = info[SMDSEntity_Tetra]   + info[SMDSEntity_Quad_Tetra] +
2104                    info[SMDSEntity_Hexa]    + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2105                    info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2106                    info[SMDSEntity_Penta]   + info[SMDSEntity_Quad_Penta] +
2107                    info[SMDSEntity_Polyhedra] +
2108                    info[SMDSEntity_Hexagonal_Prism];
2109   long nbBalls   = info[SMDSEntity_Ball];
2110
2111   long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2112   *nbElements = requestedSize;
2113
2114   *entities = SMESH_Actor::eAllEntity;
2115   *hidden   = 0;
2116
2117   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2118
2119   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2120
2121   if ( incrementalLimit ) {
2122     long total     = 0;
2123
2124     if ( nbOdElems > 0 ) {
2125       if ( total + nbOdElems > updateLimit ) {
2126         *entities = *entities & ~SMESH_Actor::e0DElements;
2127         *hidden = *hidden | SMESH_Actor::e0DElements;
2128       }
2129       else
2130         exceeded = false;
2131     }
2132     total += nbOdElems;
2133
2134     if ( nbEdges > 0 ) {
2135       if ( total + nbEdges > updateLimit ) {
2136         *entities = *entities & ~SMESH_Actor::eEdges;
2137         *hidden = *hidden | SMESH_Actor::eEdges;
2138       }
2139       else
2140         exceeded = false;
2141     }
2142     total += nbEdges;
2143
2144     if ( nbFaces > 0 ) {
2145       if ( total + nbFaces > updateLimit ) {
2146         *entities = *entities & ~SMESH_Actor::eFaces;
2147         *hidden = *hidden | SMESH_Actor::eFaces;
2148       }
2149       else
2150         exceeded = false;
2151     }
2152     total += nbFaces;
2153
2154     if ( nbVolumes > 0 ) {
2155       if ( total + nbVolumes > updateLimit ) {
2156         *entities = *entities & ~SMESH_Actor::eVolumes;
2157         *hidden = *hidden | SMESH_Actor::eVolumes;
2158       }
2159       else
2160         exceeded = false;
2161     }
2162     total += nbVolumes;
2163
2164     if ( nbBalls > 0 ) {
2165       if ( total + nbBalls > updateLimit ) {
2166         *entities = *entities & ~SMESH_Actor::eBallElem;
2167         *hidden = *hidden | SMESH_Actor::eBallElem;
2168       }
2169       else
2170         exceeded = false;
2171     }
2172     total += nbBalls;
2173   }
2174
2175   return autoUpdate && !exceeded;
2176 }
2177
2178 //=============================================================================
2179 /*!
2180  *
2181  */
2182 //=============================================================================
2183 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2184 {
2185   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2186 }
2187
2188 //=============================================================================
2189 /*!
2190  *
2191  */
2192 //=============================================================================
2193 SMESHGUI* SMESHGUI::GetSMESHGUI()
2194 {
2195   SMESHGUI* smeshMod = 0;
2196   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2197   if ( app )
2198   {
2199     CAM_Module* module = app->module( "Mesh" );
2200     smeshMod = dynamic_cast<SMESHGUI*>( module );
2201   }
2202
2203   if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2204   {
2205     SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2206     if ( study )
2207     {
2208       _PTR(Study) aStudy = study->studyDS();
2209       if ( aStudy )
2210         GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2211     }
2212   }
2213
2214   return smeshMod;
2215 }
2216
2217 extern "C"
2218 {
2219   Standard_EXPORT SMESHGUI* GetComponentGUI()
2220   {
2221     return SMESHGUI::GetSMESHGUI();
2222   }
2223 }
2224
2225 //=============================================================================
2226 /*!
2227  *
2228  */
2229 //=============================================================================
2230 void SMESHGUI::SetState(int aState)
2231 {
2232   myState = aState;
2233 }
2234
2235 //=============================================================================
2236 /*!
2237  *
2238  */
2239 //=============================================================================
2240 void SMESHGUI::ResetState()
2241 {
2242   myState = -1;
2243 }
2244
2245 //=============================================================================
2246 /*!
2247  *
2248  */
2249 //=============================================================================
2250 void SMESHGUI::EmitSignalDeactivateDialog()
2251 {
2252   emit SignalDeactivateActiveDialog();
2253 }
2254
2255 //=============================================================================
2256 /*!
2257  *
2258  */
2259 //=============================================================================
2260 void SMESHGUI::EmitSignalStudyFrameChanged()
2261 {
2262   emit SignalStudyFrameChanged();
2263 }
2264
2265 //=============================================================================
2266 /*!
2267  *
2268  */
2269 //=============================================================================
2270 void SMESHGUI::EmitSignalCloseAllDialogs()
2271 {
2272   emit SignalCloseAllDialogs();
2273 }
2274
2275 //=============================================================================
2276 /*!
2277  *
2278  */
2279 //=============================================================================
2280 void SMESHGUI::EmitSignalVisibilityChanged()
2281 {
2282   emit SignalVisibilityChanged();
2283 }
2284
2285 //=============================================================================
2286 /*!
2287  *
2288  */
2289 //=============================================================================
2290 void SMESHGUI::EmitSignalCloseView()
2291 {
2292   emit SignalCloseView();
2293 }
2294
2295 //=============================================================================
2296 /*!
2297  *
2298  */
2299 //=============================================================================
2300 void SMESHGUI::EmitSignalActivatedViewManager()
2301 {
2302   emit SignalActivatedViewManager();
2303 }
2304
2305 //=============================================================================
2306 /*!
2307  *
2308  */
2309 //=============================================================================
2310 QDialog *SMESHGUI::GetActiveDialogBox()
2311 {
2312   return myActiveDialogBox;
2313 }
2314
2315 //=============================================================================
2316 /*!
2317  *
2318  */
2319 //=============================================================================
2320 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2321 {
2322   myActiveDialogBox = (QDialog *) aDlg;
2323   return;
2324 }
2325
2326 //=============================================================================
2327 /*!
2328  *
2329  */
2330 //=============================================================================
2331 SUIT_Desktop* SMESHGUI::desktop()
2332 {
2333   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2334   if( app )
2335     return app->desktop();
2336   else
2337     return 0;
2338 }
2339
2340 //=============================================================================
2341 /*!
2342  *
2343  */
2344 //=============================================================================
2345 SalomeApp_Study* SMESHGUI::activeStudy()
2346 {
2347   SUIT_Application* app = SUIT_Session::session()->activeApplication();
2348   if( app )
2349     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2350   else
2351     return NULL;
2352 }
2353
2354 //=============================================================================
2355 /*!
2356  *
2357  */
2358 //=============================================================================
2359 void SMESHGUI::Modified( bool theIsUpdateActions )
2360 {
2361   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2362     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2363       appStudy->Modified();
2364       if( theIsUpdateActions )
2365         app->updateActions();
2366     }
2367   }
2368 }
2369
2370 //=============================================================================
2371 /*!
2372  *
2373  */
2374 //=============================================================================
2375 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2376 {
2377   /* Here the position is on the bottom right corner - 10 */
2378   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2379   aDlg->adjustSize();
2380   SUIT_Desktop *PP = desktop();
2381   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2382   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2383   return true;
2384 }
2385
2386 //=============================================================================
2387 /*!
2388  *
2389  */
2390 //=============================================================================
2391 static int isStudyLocked(_PTR(Study) theStudy){
2392   return theStudy->GetProperties()->IsLocked();
2393 }
2394
2395 static bool checkLock(_PTR(Study) theStudy) {
2396   if (isStudyLocked(theStudy)) {
2397     SUIT_MessageBox::warning( SMESHGUI::desktop(),
2398                               QObject::tr("WRN_WARNING"),
2399                               QObject::tr("WRN_STUDY_LOCKED") );
2400     return true;
2401   }
2402   return false;
2403 }
2404
2405 //=======================================================================
2406 //function : CheckActiveStudyLocked
2407 //purpose  :
2408 //=======================================================================
2409
2410 bool SMESHGUI::isActiveStudyLocked()
2411 {
2412   _PTR(Study) aStudy = activeStudy()->studyDS();
2413   return checkLock( aStudy );
2414 }
2415
2416 //=============================================================================
2417 /*!
2418  *
2419  */
2420 //=============================================================================
2421 bool SMESHGUI::OnGUIEvent( int theCommandID )
2422 {
2423   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2424   if( !anApp )
2425     return false;
2426
2427   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2428   SUIT_ResourceMgr* mgr = resourceMgr();
2429   if( !mgr )
2430     return false;
2431
2432   if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2433     GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2434   }
2435
2436   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2437   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2438
2439   //QAction* act = action( theCommandID );
2440
2441   switch (theCommandID) {
2442   case SMESHOp::OpDelete:
2443     if(checkLock(aStudy)) break;
2444     OnEditDelete();
2445     break;
2446   case SMESHOp::OpImportDAT:
2447   case SMESHOp::OpImportUNV:
2448   case SMESHOp::OpImportMED:
2449   case SMESHOp::OpImportSTL:
2450 #ifdef WITH_CGNS
2451   case SMESHOp::OpImportCGNS:
2452 #endif
2453   case SMESHOp::OpImportSAUV:
2454   case SMESHOp::OpImportGMF:
2455     {
2456       if(checkLock(aStudy)) break;
2457       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2458       break;
2459     }
2460
2461   case SMESHOp::OpFileInformation:
2462     {
2463       SALOME_ListIO selected;
2464       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2465       if( aSel )
2466         aSel->selectedObjects( selected );
2467       if( selected.Extent() )
2468       {
2469         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2470         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2471         if ( !aMesh->_is_nil() )
2472         {
2473           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2474           dlg.exec();
2475         }
2476       }
2477       break;
2478     }
2479   case SMESHOp::OpExportDAT:
2480   case SMESHOp::OpExportMED:
2481   case SMESHOp::OpExportUNV:
2482   case SMESHOp::OpExportSTL:
2483 #ifdef WITH_CGNS
2484   case SMESHOp::OpExportCGNS:
2485 #endif
2486   case SMESHOp::OpExportSAUV:
2487   case SMESHOp::OpExportGMF:
2488   case SMESHOp::OpPopupExportDAT:
2489   case SMESHOp::OpPopupExportMED:
2490   case SMESHOp::OpPopupExportUNV:
2491   case SMESHOp::OpPopupExportSTL:
2492 #ifdef WITH_CGNS
2493   case SMESHOp::OpPopupExportCGNS:
2494 #endif
2495   case SMESHOp::OpPopupExportSAUV:
2496   case SMESHOp::OpPopupExportGMF:
2497     {
2498       ::ExportMeshToFile(theCommandID);
2499       break;
2500     }
2501
2502   case SMESHOp::OpReset:                      // SCALAR BAR
2503     {
2504       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2505       SALOME_ListIO selected;
2506       if( aSel )
2507         aSel->selectedObjects( selected );
2508
2509       SALOME_ListIteratorOfListIO it(selected);
2510       for( ; it.More(); it.Next()) {
2511         Handle(SALOME_InteractiveObject) anIO = it.Value();
2512         if( anIO->hasEntry() ) {
2513           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2514             anActor->SetControlMode( SMESH_Actor::eNone );
2515 #ifndef DISABLE_PLOT2DVIEWER
2516             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2517 #endif
2518           }
2519         }
2520       }
2521       SMESH::UpdateView();
2522       break;
2523     }
2524   case SMESHOp::OpScalarBarProperties:
2525     {
2526       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2527       break;
2528     }
2529   case SMESHOp::OpShowScalarBar:
2530     {
2531       // show/hide scalar bar
2532       ::ShowElement(theCommandID);
2533       break;
2534     }
2535   case SMESHOp::OpSaveDistribution:
2536     {
2537       // dump control distribution data to the text file
2538       ::SaveDistribution();
2539       break;
2540     }
2541
2542   case SMESHOp::OpShowDistribution:
2543     {
2544       // show/hide distribution
2545       ::ShowElement(theCommandID);
2546       break;
2547     }
2548
2549 #ifndef DISABLE_PLOT2DVIEWER
2550   case SMESHOp::OpPlotDistribution:
2551     {
2552       // plot distribution
2553       ::PlotDistribution();
2554       break;
2555     }
2556 #endif
2557
2558     // Auto-color
2559   case SMESHOp::OpAutoColor:
2560     ::AutoColor();
2561   break;
2562
2563   case SMESHOp::OpDisableAutoColor:
2564     ::DisableAutoColor();
2565   break;
2566
2567   case SMESHOp::OpClipping:
2568   case SMESHOp::OpTransparency:
2569   case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2570
2571     // Display Mode
2572   case SMESHOp::OpDMWireframe:
2573   case SMESHOp::OpDMShading:
2574   case SMESHOp::OpDMNodes:
2575   case SMESHOp::OpDMShrink:
2576     ::SetDisplayMode(theCommandID, myMarkerMap);
2577   break;
2578
2579   //2D quadratic representation
2580   case SMESHOp::OpRepresentationLines:
2581   case SMESHOp::OpRepresentationArcs:
2582     ::SetDisplayMode(theCommandID, myMarkerMap);
2583   break;
2584
2585   // Display Entity
2586   case SMESHOp::OpDE0DElements:
2587   case SMESHOp::OpDEEdges:
2588   case SMESHOp::OpDEFaces:
2589   case SMESHOp::OpDEVolumes:
2590   case SMESHOp::OpDEBalls:
2591   case SMESHOp::OpDEAllEntity:
2592     ::SetDisplayEntity(theCommandID);
2593   break;
2594
2595   // Choose entities to be displayed
2596   case SMESHOp::OpDEChoose:
2597     {
2598       ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2599       break;
2600     }
2601
2602   case SMESHOp::OpOrientationOnFaces:
2603     {
2604       SUIT_OverrideCursor wc;
2605       LightApp_SelectionMgr* mgr = selectionMgr();
2606       SALOME_ListIO selected; mgr->selectedObjects( selected );
2607
2608       SALOME_ListIteratorOfListIO it(selected);
2609       for( ; it.More(); it.Next()) {
2610         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2611         if(anIObject->hasEntry()) {
2612           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2613             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2614           }
2615         }
2616       }
2617       break;
2618     }
2619
2620   case SMESHOp::OpUpdate:
2621     {
2622       if(checkLock(aStudy)) break;
2623       SUIT_OverrideCursor wc;
2624       try {
2625 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2626         OCC_CATCH_SIGNALS;
2627 #endif
2628         SMESH::UpdateView();
2629       }
2630       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2631         SMESH::OnVisuException();
2632       }
2633       catch (...) { // PAL16774 (Crash after display of many groups)
2634         SMESH::OnVisuException();
2635       }
2636
2637       SALOME_ListIO l;
2638       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2639       aSel->selectedObjects( l );
2640       aSel->setSelectedObjects( l );
2641       break;
2642     }
2643
2644   case SMESHOp::OpHide:
2645   case SMESHOp::OpShow:
2646   case SMESHOp::OpShowOnly:
2647     {
2648       SUIT_OverrideCursor wc;
2649       SMESH::EDisplaing anAction;
2650       switch (theCommandID) {
2651       case SMESHOp::OpHide:     anAction = SMESH::eErase; break;
2652       case SMESHOp::OpShow:     anAction = SMESH::eDisplay; break;
2653       case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2654       }
2655
2656       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2657       SALOME_ListIO sel_objects, to_process;
2658       if (aSel)
2659         aSel->selectedObjects( sel_objects );
2660
2661       if ( theCommandID==SMESHOp::OpShowOnly )
2662       {
2663         //MESSAGE("anAction = SMESH::eDisplayOnly");
2664         startOperation( myEraseAll );
2665       }
2666
2667       extractContainers( sel_objects, to_process );
2668
2669       try {
2670 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2671         OCC_CATCH_SIGNALS;
2672 #endif
2673         if (vtkwnd) {
2674           SALOME_ListIteratorOfListIO It( to_process );
2675           for ( ; It.More(); It.Next())
2676           {
2677             Handle(SALOME_InteractiveObject) IOS = It.Value();
2678             if ( IOS->hasEntry() )
2679             {
2680               if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2681                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2682                 break; // PAL16774 (Crash after display of many groups)
2683               }
2684               if (anAction == SMESH::eDisplayOnly)
2685                 anAction = SMESH::eDisplay;
2686             }
2687           }
2688         }
2689
2690         // PAL13338 + PAL15161 -->
2691         if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2692           SMESH::UpdateView();
2693           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2694         }
2695         // PAL13338 + PAL15161 <--
2696       }
2697       catch (...) { // PAL16774 (Crash after display of many groups)
2698         SMESH::OnVisuException();
2699       }
2700
2701       if (anAction == SMESH::eErase) {
2702         SALOME_ListIO l1;
2703         aSel->setSelectedObjects( l1 );
2704       }
2705       else
2706         aSel->setSelectedObjects( to_process );
2707
2708       break;
2709     }
2710
2711   case SMESHOp::OpNode:
2712     {
2713       if(checkLock(aStudy)) break;
2714
2715       if ( vtkwnd ) {
2716         EmitSignalDeactivateDialog();
2717
2718         ( new SMESHGUI_NodesDlg( this ) )->show();
2719       }
2720       else {
2721         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2722       }
2723       break;
2724     }
2725
2726   case SMESHOp::OpCreateMesh:
2727   case SMESHOp::OpCreateSubMesh:
2728   case SMESHOp::OpEditMeshOrSubMesh:
2729   case SMESHOp::OpEditMesh:
2730   case SMESHOp::OpEditSubMesh:
2731   case SMESHOp::OpCompute:
2732   case SMESHOp::OpComputeSubMesh:
2733   case SMESHOp::OpPreCompute:
2734   case SMESHOp::OpEvaluate:
2735   case SMESHOp::OpMeshOrder:
2736     startOperation( theCommandID );
2737     break;
2738   case SMESHOp::OpCopyMesh:
2739     {
2740       if (checkLock(aStudy)) break;
2741       EmitSignalDeactivateDialog();
2742       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2743     }
2744     break;
2745   case SMESHOp::OpBuildCompoundMesh:
2746     {
2747       if (checkLock(aStudy)) break;
2748       EmitSignalDeactivateDialog();
2749       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2750     }
2751     break;
2752
2753   case SMESHOp::OpDiagonalInversion:
2754   case SMESHOp::OpUnionOfTwoTriangle:
2755     {
2756       if ( !vtkwnd )
2757       {
2758         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2759         break;
2760       }
2761
2762       if ( checkLock( aStudy ) )
2763         break;
2764
2765       /*Standard_Boolean aRes;
2766       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2767       if ( aMesh->_is_nil() )
2768       {
2769         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2770           tr( "SMESH_BAD_SELECTION" ) );
2771         break;
2772       }
2773       */
2774       EmitSignalDeactivateDialog();
2775       if ( theCommandID == SMESHOp::OpDiagonalInversion )
2776         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2777       else
2778         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2779       break;
2780     }
2781   case SMESHOp::OpOrientation:
2782   case SMESHOp::OpUnionOfTriangles:
2783   case SMESHOp::OpCuttingOfQuadrangles:
2784   case SMESHOp::OpSplitVolumes:
2785     {
2786       if ( !vtkwnd )
2787       {
2788         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2789         break;
2790       }
2791
2792       if ( checkLock( aStudy ) )
2793         break;
2794
2795       EmitSignalDeactivateDialog();
2796       SMESHGUI_MultiEditDlg* aDlg = NULL;
2797       if ( theCommandID == SMESHOp::OpOrientation )
2798         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2799       else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2800         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2801       else if ( theCommandID == SMESHOp::OpSplitVolumes )
2802         aDlg = new SMESHGUI_SplitVolumesDlg(this);
2803       else
2804         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2805
2806       aDlg->show();
2807       break;
2808     }
2809   case SMESHOp::OpSmoothing:
2810     {
2811       if(checkLock(aStudy)) break;
2812       if( vtkwnd ) {
2813         EmitSignalDeactivateDialog();
2814         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2815       }
2816       else {
2817         SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2818       }
2819       break;
2820     }
2821   case SMESHOp::OpExtrusion:
2822     {
2823       if (checkLock(aStudy)) break;
2824       if (vtkwnd) {
2825         EmitSignalDeactivateDialog();
2826         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2827       } else {
2828         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2829       }
2830       break;
2831     }
2832   case SMESHOp::OpExtrusionAlongAPath:
2833     {
2834       if (checkLock(aStudy)) break;
2835       if (vtkwnd) {
2836         EmitSignalDeactivateDialog();
2837         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2838       } else {
2839         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2840       }
2841       break;
2842     }
2843   case SMESHOp::OpRevolution:
2844     {
2845       if(checkLock(aStudy)) break;
2846       if( vtkwnd ) {
2847         EmitSignalDeactivateDialog();
2848         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2849       }
2850       else {
2851         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2852       }
2853       break;
2854     }
2855   case SMESHOp::OpPatternMapping:
2856     {
2857       if ( checkLock( aStudy ) )
2858         break;
2859       if ( vtkwnd )
2860       {
2861         EmitSignalDeactivateDialog();
2862         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2863       }
2864       else {
2865         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2866       }
2867       break;
2868     }
2869   case SMESHOp::OpSplitBiQuadratic:
2870   case SMESHOp::OpConvertMeshToQuadratic:
2871   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2872   case SMESHOp::OpReorientFaces:
2873   case SMESHOp::OpCreateGeometryGroup:
2874     {
2875       startOperation( theCommandID );
2876       break;
2877     }
2878   case SMESHOp::OpCreateGroup:
2879     {
2880       if ( !vtkwnd )
2881       {
2882         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2883         break;
2884       }
2885
2886       if(checkLock(aStudy)) break;
2887       EmitSignalDeactivateDialog();
2888       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2889
2890       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2891       SALOME_ListIO selected;
2892       if( aSel )
2893         aSel->selectedObjects( selected );
2894
2895       int nbSel = selected.Extent();
2896       if (nbSel == 1) {
2897         // check if mesh is selected
2898         aMesh = SMESH::GetMeshByIO( selected.First() );
2899       }
2900       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2901       aDlg->show();
2902       break;
2903     }
2904
2905   case SMESHOp::OpConstructGroup:
2906     {
2907       if ( !vtkwnd )
2908       {
2909         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2910         break;
2911       }
2912
2913       if(checkLock(aStudy)) break;
2914       EmitSignalDeactivateDialog();
2915
2916       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2917       SALOME_ListIO selected;
2918       if( aSel )
2919         aSel->selectedObjects( selected );
2920
2921       int nbSel = selected.Extent();
2922       if (nbSel == 1) {
2923         // check if submesh is selected
2924         Handle(SALOME_InteractiveObject) IObject = selected.First();
2925         if (IObject->hasEntry()) {
2926           _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2927           if( aSObj ) {
2928             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2929             if (!aSubMesh->_is_nil()) {
2930               try {
2931                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2932                 // get submesh elements list by types
2933                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2934                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2935                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2936                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2937                 // create group for each type o elements
2938                 QString aName = IObject->getName();
2939                 QStringList anEntryList;
2940                 if (aNodes->length() > 0) {
2941                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2942                   aGroup->Add(aNodes.inout());
2943                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2944                     anEntryList.append( aSObject->GetID().c_str() );
2945                 }
2946                 if (aEdges->length() > 0) {
2947                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2948                   aGroup->Add(aEdges.inout());
2949                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2950                     anEntryList.append( aSObject->GetID().c_str() );
2951                 }
2952                 if (aFaces->length() > 0) {
2953                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2954                   aGroup->Add(aFaces.inout());
2955                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2956                     anEntryList.append( aSObject->GetID().c_str() );
2957                 }
2958                 if (aVolumes->length() > 0) {
2959                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2960                   aGroup->Add(aVolumes.inout());
2961                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2962                     anEntryList.append( aSObject->GetID().c_str() );
2963                 }
2964                 updateObjBrowser();
2965                 anApp->browseObjects( anEntryList );
2966               }
2967               catch(const SALOME::SALOME_Exception & S_ex){
2968                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2969               }
2970             }
2971           }
2972         }
2973       }
2974       else if(nbSel==0) {
2975         SUIT_MessageBox::warning(desktop(),
2976                                  tr("SMESH_WRN_WARNING"),
2977                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2978       }
2979       break;
2980     }
2981
2982   case SMESHOp::OpEditGroup:
2983     {
2984       if ( !vtkwnd )
2985       {
2986         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2987         break;
2988       }
2989
2990       if(checkLock(aStudy)) break;
2991       EmitSignalDeactivateDialog();
2992
2993       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2994       SALOME_ListIO selected;
2995       if( aSel )
2996         aSel->selectedObjects( selected );
2997
2998       SALOME_ListIteratorOfListIO It (selected);
2999       int nbSelectedGroups = 0;
3000       for ( ; It.More(); It.Next() )
3001       {
3002         SMESH::SMESH_GroupBase_var aGroup =
3003           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3004         if (!aGroup->_is_nil()) {
3005           nbSelectedGroups++;
3006           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3007           aDlg->show();
3008         }
3009       }
3010       if (nbSelectedGroups == 0)
3011         {
3012           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3013           aDlg->show();
3014         }
3015       break;
3016     }
3017
3018   case SMESHOp::OpAddElemGroupPopup:     // Add elements to group
3019     {
3020       if(checkLock(aStudy)) break;
3021       if (myState == 800) {
3022         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3023         if (aDlg) aDlg->onAdd();
3024       }
3025       break;
3026     }
3027
3028   case SMESHOp::OpRemoveElemGroupPopup:  // Remove elements from group
3029     {
3030       if(checkLock(aStudy)) break;
3031       if (myState == 800) {
3032         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3033         if (aDlg) aDlg->onRemove();
3034       }
3035       break;
3036     }
3037
3038   case SMESHOp::OpEditGeomGroupAsGroup:
3039     {
3040       if ( !vtkwnd )
3041       {
3042         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3043         break;
3044       }
3045
3046       if(checkLock(aStudy)) break;
3047       EmitSignalDeactivateDialog();
3048
3049       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3050       SALOME_ListIO selected;
3051       if( aSel )
3052         aSel->selectedObjects( selected );
3053
3054       SALOME_ListIteratorOfListIO It (selected);
3055       for ( ; It.More(); It.Next() )
3056       {
3057         SMESH::SMESH_GroupOnGeom_var aGroup =
3058           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3059         if (!aGroup->_is_nil()) {
3060           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3061           aDlg->show();
3062         }
3063         else
3064         {
3065           SMESH::SMESH_GroupOnFilter_var aGroup =
3066             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3067           if (!aGroup->_is_nil()) {
3068             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3069             aDlg->show();
3070           }
3071         }
3072       }
3073       break;
3074     }
3075
3076     case SMESHOp::OpUnionGroups:
3077     case SMESHOp::OpIntersectGroups:
3078     case SMESHOp::OpCutGroups:
3079     {
3080       if ( !vtkwnd )
3081       {
3082         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3083         break;
3084       }
3085
3086       if ( checkLock( aStudy ) )
3087         break;
3088
3089       EmitSignalDeactivateDialog();
3090
3091       SMESHGUI_GroupOpDlg* aDlg = 0;
3092       if ( theCommandID == SMESHOp::OpUnionGroups )
3093         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3094       else if ( theCommandID == SMESHOp::OpIntersectGroups )
3095         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3096       else
3097         aDlg = new SMESHGUI_CutGroupsDlg( this );
3098
3099       aDlg->show();
3100
3101       break;
3102     }
3103
3104     case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3105     {
3106       if ( checkLock( aStudy ) )
3107         break;
3108
3109       EmitSignalDeactivateDialog();
3110       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3111       aDlg->show();
3112
3113       break;
3114     }
3115
3116     case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3117     {
3118       if ( !vtkwnd )
3119       {
3120         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3121         break;
3122       }
3123
3124       if ( checkLock( aStudy ) )
3125         break;
3126
3127       EmitSignalDeactivateDialog();
3128
3129       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3130       break;
3131     }
3132
3133   case SMESHOp::OpMeshInformation:
3134   case SMESHOp::OpWhatIs:
3135     {
3136       int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3137       EmitSignalDeactivateDialog();
3138       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3139       SALOME_ListIO selected;
3140       if( aSel )
3141         aSel->selectedObjects( selected );
3142
3143       if ( selected.Extent() > 1 ) { // a dlg for each IO
3144         SALOME_ListIteratorOfListIO It( selected );
3145         for ( ; It.More(); It.Next() ) {
3146           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3147           dlg->showInfo( It.Value() );
3148           dlg->show();
3149         }
3150       }
3151       else {
3152         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3153         dlg->show();
3154       }
3155       break;
3156     }
3157
3158   case SMESHOp::OpFindElementByPoint:
3159     {
3160       startOperation( theCommandID );
3161       break;
3162     }
3163
3164   case SMESHOp::OpEditHypothesis:
3165     {
3166       if(checkLock(aStudy)) break;
3167
3168       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3169       SALOME_ListIO selected;
3170       if( aSel )
3171         aSel->selectedObjects( selected );
3172
3173       int nbSel = selected.Extent();
3174
3175       if (nbSel == 1) {
3176         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3177         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3178
3179         if ( !aHypothesis->_is_nil() )
3180         {
3181           SMESHGUI_GenericHypothesisCreator* aCreator =
3182             SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3183           if (aCreator)
3184           {
3185             // set geometry of mesh and sub-mesh to aCreator
3186             aSel->selectedObjects( selected, "",  /*convertReferences=*/false);
3187             if ( selected.Extent() == 1 )
3188             {
3189               QString subGeomID, meshGeomID;
3190               Handle(SALOME_InteractiveObject) hypIO = selected.First();
3191               if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3192               {
3193                 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3194                 aCreator->setShapeEntry( subGeomID );
3195                 aCreator->setMainShapeEntry( meshGeomID );
3196               }
3197             }
3198
3199             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3200           }
3201           else
3202           {
3203             // report error
3204           }
3205         }
3206       }
3207       break;
3208     }
3209   case SMESHOp::OpUnassign:                      // REMOVE HYPOTHESIS / ALGORITHMS
3210     {
3211       if(checkLock(aStudy)) break;
3212       SUIT_OverrideCursor wc;
3213
3214       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3215       SALOME_ListIO selected;
3216       if( aSel )
3217         aSel->selectedObjects( selected, QString::null, false );
3218
3219       SALOME_ListIteratorOfListIO It(selected);
3220       for (int i = 0; It.More(); It.Next(), i++) {
3221         Handle(SALOME_InteractiveObject) IObject = It.Value();
3222         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3223       }
3224       SALOME_ListIO l1;
3225       aSel->setSelectedObjects( l1 );
3226       updateObjBrowser();
3227       break;
3228     }
3229
3230   case SMESHOp::OpElem0D:
3231   case SMESHOp::OpBall:
3232   case SMESHOp::OpEdge:
3233   case SMESHOp::OpTriangle:
3234   case SMESHOp::OpQuadrangle:
3235   case SMESHOp::OpPolygon:
3236   case SMESHOp::OpTetrahedron:
3237   case SMESHOp::OpHexahedron:
3238   case SMESHOp::OpPentahedron:
3239   case SMESHOp::OpPyramid:
3240   case SMESHOp::OpHexagonalPrism:
3241     {
3242       if(checkLock(aStudy)) break;
3243       if ( vtkwnd ) {
3244         EmitSignalDeactivateDialog();
3245         SMDSAbs_EntityType type = SMDSEntity_Edge;
3246         switch (theCommandID) {
3247         case SMESHOp::OpElem0D: type = SMDSEntity_0D;                      break;
3248         case SMESHOp::OpBall: type = SMDSEntity_Ball;                      break;
3249         case SMESHOp::OpTriangle: type = SMDSEntity_Triangle;              break;
3250         case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle;          break;
3251         case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra;              break;
3252         case SMESHOp::OpPolygon: type = SMDSEntity_Polygon;                break;
3253         case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa;                break;
3254         case SMESHOp::OpPentahedron: type = SMDSEntity_Penta;              break;
3255         case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid;                break;
3256         case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3257         default:;
3258         }
3259         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3260       }
3261       else {
3262         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3263       }
3264       break;
3265     }
3266   case SMESHOp::OpPolyhedron:
3267     {
3268       if(checkLock(aStudy)) break;
3269       if ( vtkwnd ) {
3270         EmitSignalDeactivateDialog();
3271         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3272       }
3273       else {
3274         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3275       }
3276       break;
3277     }
3278   case SMESHOp::OpQuadraticEdge:
3279   case SMESHOp::OpQuadraticTriangle:
3280   case SMESHOp::OpBiQuadraticTriangle:
3281   case SMESHOp::OpQuadraticQuadrangle:
3282   case SMESHOp::OpBiQuadraticQuadrangle:
3283   case SMESHOp::OpQuadraticPolygon:
3284   case SMESHOp::OpQuadraticTetrahedron:
3285   case SMESHOp::OpQuadraticPyramid:
3286   case SMESHOp::OpQuadraticPentahedron:
3287   case SMESHOp::OpQuadraticHexahedron:
3288   case SMESHOp::OpTriQuadraticHexahedron:
3289     {
3290       if(checkLock(aStudy)) break;
3291       if ( vtkwnd ) {
3292         EmitSignalDeactivateDialog();
3293         SMDSAbs_EntityType type = SMDSEntity_Last;
3294
3295         switch (theCommandID) {
3296         case SMESHOp::OpQuadraticEdge:          type = SMDSEntity_Quad_Edge; break;
3297         case SMESHOp::OpQuadraticTriangle:      type = SMDSEntity_Quad_Triangle; break;
3298         case SMESHOp::OpBiQuadraticTriangle:    type = SMDSEntity_BiQuad_Triangle; break;
3299         case SMESHOp::OpQuadraticQuadrangle:    type = SMDSEntity_Quad_Quadrangle; break;
3300         case SMESHOp::OpBiQuadraticQuadrangle:  type = SMDSEntity_BiQuad_Quadrangle; break;
3301         case SMESHOp::OpQuadraticPolygon:       type = SMDSEntity_Quad_Polygon; break;
3302         case SMESHOp::OpQuadraticTetrahedron:   type = SMDSEntity_Quad_Tetra; break;
3303         case SMESHOp::OpQuadraticPyramid:       type = SMDSEntity_Quad_Pyramid; break;
3304         case SMESHOp::OpQuadraticPentahedron:   type = SMDSEntity_Quad_Penta; break;
3305         case SMESHOp::OpQuadraticHexahedron:    type = SMDSEntity_Quad_Hexa; break;
3306         case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3307         default: break;
3308         }
3309         if ( type != SMDSEntity_Last )
3310           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3311       }
3312       else {
3313         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3314                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3315       }
3316       break;
3317     }
3318   case SMESHOp::OpRemoveNodes:
3319     {
3320       if(checkLock(aStudy)) break;
3321       if ( vtkwnd ) {
3322         EmitSignalDeactivateDialog();
3323         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3324       }
3325       else {
3326         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3327                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3328       }
3329       break;
3330     }
3331   case SMESHOp::OpRemoveElements:                                    // REMOVES ELEMENTS
3332     {
3333       if(checkLock(aStudy)) break;
3334       if( vtkwnd ) {
3335         EmitSignalDeactivateDialog();
3336         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3337       }
3338       else
3339         {
3340           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3341                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3342         }
3343       break;
3344     }
3345   case SMESHOp::OpClearMesh: {
3346
3347     if(checkLock(aStudy)) break;
3348
3349     SALOME_ListIO selected;
3350     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3351       aSel->selectedObjects( selected );
3352
3353     SUIT_OverrideCursor wc;
3354     SALOME_ListIteratorOfListIO It (selected);
3355     for ( ; It.More(); It.Next() )
3356     {
3357       Handle(SALOME_InteractiveObject) IOS = It.Value();
3358       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3359       if ( aMesh->_is_nil()) continue;
3360       try {
3361         aMesh->Clear();
3362         if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3363           SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3364         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3365         SMESH::ModifiedMesh( aMeshSObj, false, true);
3366         // hide groups and submeshes
3367         _PTR(ChildIterator) anIter =
3368           SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3369         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3370         {
3371           _PTR(SObject) so = anIter->Value();
3372           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3373         }
3374       }
3375       catch (const SALOME::SALOME_Exception& S_ex){
3376         wc.suspend();
3377         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3378         wc.resume();
3379       }
3380     }
3381     SMESH::UpdateView();
3382     updateObjBrowser();
3383     break;
3384   }
3385   case SMESHOp::OpRemoveOrphanNodes:
3386     {
3387       if(checkLock(aStudy)) break;
3388       SALOME_ListIO selected;
3389       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3390         aSel->selectedObjects( selected );
3391       if ( selected.Extent() == 1 ) {
3392         Handle(SALOME_InteractiveObject) anIO = selected.First();
3393         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3394         if ( !aMesh->_is_nil() ) {
3395           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3396                                                     tr( "SMESH_WARNING" ),
3397                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3398                                                     SUIT_MessageBox::Yes |
3399                                                     SUIT_MessageBox::No,
3400                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3401           if( confirm ) {
3402             try {
3403               SUIT_OverrideCursor wc;
3404               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3405               int removed = aMeshEditor->RemoveOrphanNodes();
3406               SUIT_MessageBox::information(SMESHGUI::desktop(),
3407                                            tr("SMESH_INFORMATION"),
3408                                            tr("NB_NODES_REMOVED").arg(removed));
3409               if ( removed > 0 ) {
3410                 SMESH::UpdateView();
3411                 SMESHGUI::Modified();
3412               }
3413             }
3414             catch (const SALOME::SALOME_Exception& S_ex) {
3415               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3416             }
3417             catch (...) {
3418             }
3419           }
3420         }
3421       }
3422       break;
3423     }
3424   case SMESHOp::OpRenumberingNodes:
3425     {
3426       if(checkLock(aStudy)) break;
3427       if( vtkwnd ) {
3428         EmitSignalDeactivateDialog();
3429         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3430       }
3431       else
3432         {
3433           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3434                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3435         }
3436       break;
3437     }
3438   case SMESHOp::OpRenumberingElements:
3439     {
3440       if(checkLock(aStudy)) break;
3441       if ( vtkwnd ) {
3442         EmitSignalDeactivateDialog();
3443         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3444       }
3445       else
3446         {
3447           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3448                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3449         }
3450       break;
3451     }
3452   case SMESHOp::OpTranslation:
3453     {
3454       if(checkLock(aStudy)) break;
3455       if ( vtkwnd ) {
3456         EmitSignalDeactivateDialog();
3457         ( new SMESHGUI_TranslationDlg( this ) )->show();
3458       }
3459       else {
3460         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3461                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3462       }
3463       break;
3464     }
3465   case SMESHOp::OpRotation:
3466     {
3467       if(checkLock(aStudy)) break;
3468       if( vtkwnd ) {
3469         EmitSignalDeactivateDialog();
3470         ( new SMESHGUI_RotationDlg( this ) )->show();
3471       }
3472       else {
3473         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3474                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3475       }
3476       break;
3477     }
3478   case SMESHOp::OpSymmetry:
3479     {
3480       if(checkLock(aStudy)) break;
3481       if(vtkwnd) {
3482         EmitSignalDeactivateDialog();
3483         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3484       }
3485       else {
3486         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3487                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3488       }
3489       break;
3490     }
3491   case SMESHOp::OpScale:
3492     {
3493       if(checkLock(aStudy)) break;
3494       if ( vtkwnd ) {
3495         EmitSignalDeactivateDialog();
3496         ( new SMESHGUI_ScaleDlg( this ) )->show();
3497       }
3498       else {
3499         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3500                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3501       }
3502       break;
3503     }
3504
3505   case SMESHOp::OpSewing:
3506     {
3507       if(checkLock(aStudy)) break;
3508       if(vtkwnd) {
3509         EmitSignalDeactivateDialog();
3510         ( new SMESHGUI_SewingDlg( this ) )->show();
3511       }
3512       else {
3513         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3514                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3515       }
3516       break;
3517     }
3518   case SMESHOp::OpMergeNodes:
3519     {
3520       if(checkLock(aStudy)) break;
3521       if(vtkwnd) {
3522         EmitSignalDeactivateDialog();
3523         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3524       }
3525       else {
3526         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3527                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3528       }
3529       break;
3530     }
3531   case SMESHOp::OpMergeElements:
3532     {
3533       if (checkLock(aStudy)) break;
3534       if (vtkwnd) {
3535         EmitSignalDeactivateDialog();
3536         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3537       } else {
3538         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3539                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3540       }
3541       break;
3542     }
3543
3544   case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3545     startOperation( SMESHOp::OpMoveNode );
3546     break;
3547
3548   case SMESHOp::OpDuplicateNodes:
3549     {
3550       if(checkLock(aStudy)) break;
3551       if ( vtkwnd ) {
3552         EmitSignalDeactivateDialog();
3553         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3554       }
3555       else {
3556         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3557                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3558       }
3559       break;
3560     }
3561
3562   case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3563     startOperation( SMESHOp::OpElem0DOnElemNodes );
3564     break;
3565
3566   case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3567   {
3568     static QList<int> aTypes;
3569     if ( aTypes.isEmpty() )
3570     {
3571       aTypes.append( SMESH::NODE );
3572       aTypes.append( SMESH::EDGE );
3573       aTypes.append( SMESH::FACE );
3574       aTypes.append( SMESH::VOLUME );
3575     }
3576     if (!myFilterLibraryDlg)
3577       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3578     else if (myFilterLibraryDlg->isHidden())
3579       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3580     myFilterLibraryDlg->raise();
3581   }
3582   break;
3583   // CONTROLS
3584   case SMESHOp::OpFreeNode:
3585   case SMESHOp::OpEqualNode:
3586   case SMESHOp::OpNodeConnectivityNb:
3587   case SMESHOp::OpFreeEdge:
3588   case SMESHOp::OpFreeBorder:
3589   case SMESHOp::OpLength:
3590   case SMESHOp::OpConnection:
3591   case SMESHOp::OpEqualEdge:
3592   case SMESHOp::OpFreeFace:
3593   case SMESHOp::OpBareBorderFace:
3594   case SMESHOp::OpOverConstrainedFace:
3595   case SMESHOp::OpLength2D:
3596   case SMESHOp::OpConnection2D:
3597   case SMESHOp::OpArea:
3598   case SMESHOp::OpTaper:
3599   case SMESHOp::OpAspectRatio:
3600   case SMESHOp::OpMinimumAngle:
3601   case SMESHOp::OpWarpingAngle:
3602   case SMESHOp::OpSkew:
3603   case SMESHOp::OpMaxElementLength2D:
3604   case SMESHOp::OpEqualFace:
3605   case SMESHOp::OpAspectRatio3D:
3606   case SMESHOp::OpVolume:
3607   case SMESHOp::OpMaxElementLength3D:
3608   case SMESHOp::OpBareBorderVolume:
3609   case SMESHOp::OpOverConstrainedVolume:
3610   case SMESHOp::OpEqualVolume:
3611     if ( vtkwnd ) {
3612
3613       LightApp_SelectionMgr* mgr = selectionMgr();
3614       SALOME_ListIO selected; mgr->selectedObjects( selected );
3615
3616       if( !selected.IsEmpty() ) {
3617         SUIT_OverrideCursor wc;
3618         ::Control( theCommandID );
3619         break;
3620       }
3621       SUIT_MessageBox::warning(desktop(),
3622                                tr( "SMESH_WRN_WARNING" ),
3623                                tr( "SMESH_BAD_SELECTION" ) );
3624       break;
3625     }
3626     else {
3627       SUIT_MessageBox::warning(desktop(),
3628                                tr( "SMESH_WRN_WARNING" ),
3629                                tr( "NOT_A_VTK_VIEWER" ) );
3630     }
3631     break;
3632   case SMESHOp::OpOverallMeshQuality:
3633     OverallMeshQuality();
3634     break;
3635   case SMESHOp::OpNumberingNodes:
3636     {
3637       SUIT_OverrideCursor wc;
3638       LightApp_SelectionMgr* mgr = selectionMgr();
3639       SALOME_ListIO selected; mgr->selectedObjects( selected );
3640
3641       SALOME_ListIteratorOfListIO it(selected);
3642       for( ; it.More(); it.Next()) {
3643         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3644         if(anIObject->hasEntry()) {
3645           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3646             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3647           }
3648         }
3649       }
3650       break;
3651     }
3652   case SMESHOp::OpNumberingElements:
3653     {
3654       SUIT_OverrideCursor wc;
3655       LightApp_SelectionMgr* mgr = selectionMgr();
3656       SALOME_ListIO selected; mgr->selectedObjects( selected );
3657
3658       SALOME_ListIteratorOfListIO it(selected);
3659       for( ; it.More(); it.Next()) {
3660         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3661         if(anIObject->hasEntry())
3662           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3663             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3664           }
3665       }
3666       break;
3667     }
3668   case SMESHOp::OpPropertiesLength:
3669   case SMESHOp::OpPropertiesArea:
3670   case SMESHOp::OpPropertiesVolume:
3671   case SMESHOp::OpMinimumDistance:
3672   case SMESHOp::OpBoundingBox:
3673     {
3674       int page = SMESHGUI_MeasureDlg::MinDistance;
3675       if ( theCommandID == SMESHOp::OpBoundingBox )
3676         page = SMESHGUI_MeasureDlg::BoundingBox;
3677       else if ( theCommandID == SMESHOp::OpPropertiesLength )
3678         page = SMESHGUI_MeasureDlg::Length;
3679       else if ( theCommandID == SMESHOp::OpPropertiesArea )
3680         page = SMESHGUI_MeasureDlg::Area;
3681       else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3682         page = SMESHGUI_MeasureDlg::Volume;
3683
3684       EmitSignalDeactivateDialog();
3685       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3686       dlg->show();
3687       break;
3688     }
3689   case SMESHOp::OpSortChild:
3690     ::sortChildren();
3691     break;
3692
3693   }
3694
3695   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3696   //updateObjBrowser();
3697   return true;
3698 }
3699
3700 //=============================================================================
3701 /*!
3702  *
3703  */
3704 //=============================================================================
3705 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3706 {
3707   return false;
3708 }
3709
3710 //=============================================================================
3711 /*!
3712  *
3713  */
3714 //=============================================================================
3715 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3716 {
3717   return true;
3718 }
3719
3720 //=============================================================================
3721 /*!
3722  *
3723  */
3724 //=============================================================================
3725 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3726 {
3727   return true;
3728 }
3729
3730 //=============================================================================
3731 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3732  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3733  */
3734 //=============================================================================
3735 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3736                                   SUIT_ViewWindow* wnd )
3737 {
3738   if(theIO->hasEntry()){
3739     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3740     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3741   }
3742 }
3743
3744 //=======================================================================
3745 // function : createSMESHAction
3746 // purpose  :
3747 //=======================================================================
3748 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3749                                   const int key, const bool toggle, const QString& shortcutAction  )
3750 {
3751   QIcon icon;
3752   QWidget* parent = application()->desktop();
3753   SUIT_ResourceMgr* resMgr = resourceMgr();
3754   QPixmap pix;
3755   if ( !icon_id.isEmpty() )
3756     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3757   else
3758     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3759   if ( !pix.isNull() )
3760     icon = QIcon( pix );
3761
3762   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3763           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3764           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3765
3766   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3767                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3768 }
3769
3770 //=======================================================================
3771 // function : createPopupItem
3772 // purpose  :
3773 //=======================================================================
3774 void SMESHGUI::createPopupItem( const int id,
3775                                 const QString& clients,
3776                                 const QString& types,
3777                                 const QString& theRule,
3778                                 const int pId )
3779 {
3780   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3781     popupMgr()->insert( action( id ), pId, 0 );
3782
3783   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3784   QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3785   QString rule = "(%1) and (%2) and (%3)";
3786   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3787   if( clients.isEmpty() )
3788     rule = rule.arg( QString( "true" ) );
3789   else
3790     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3791   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3792   rule += theRule;
3793
3794   bool cont = myRules.contains( id );
3795   if( cont )
3796     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3797
3798   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3799   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3800 }
3801
3802 //=======================================================================
3803 // function : initialize
3804 // purpose  :
3805 //=======================================================================
3806 void SMESHGUI::initialize( CAM_Application* app )
3807 {
3808   SalomeApp_Module::initialize( app );
3809
3810 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3811 //   if ( mgr )
3812   /* Automatic Update flag */
3813 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3814
3815   // ----- create actions --------------
3816
3817   //createSMESHAction(  SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3818   createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3819   createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3820   //createSMESHAction(  114, "NUM" );
3821   createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL"  );
3822 #ifdef WITH_CGNS
3823   createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3824 #endif
3825   createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3826   createSMESHAction( SMESHOp::OpImportGMF,  "IMPORT_GMF"  );
3827   createSMESHAction( SMESHOp::OpExportDAT,  "DAT" );
3828   createSMESHAction( SMESHOp::OpExportMED,  "MED" );
3829   createSMESHAction( SMESHOp::OpExportUNV,  "UNV" );
3830   createSMESHAction( SMESHOp::OpExportSTL,  "STL" );
3831 #ifdef WITH_CGNS
3832   createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3833 #endif
3834   createSMESHAction( SMESHOp::OpExportSAUV,     "SAUV");
3835   createSMESHAction( SMESHOp::OpExportGMF,      "GMF" );
3836   createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3837   createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3838   createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3839   createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3840 #ifdef WITH_CGNS
3841   createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3842 #endif
3843   createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3844   createSMESHAction( SMESHOp::OpPopupExportGMF,  "GMF" );
3845   createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3846   createSMESHAction( SMESHOp::OpDelete,          "DELETE", "ICON_DELETE", Qt::Key_Delete );
3847   createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3848   createSMESHAction( SMESHOp::OpCreateMesh,           "CREATE_MESH",             "ICON_DLG_INIT_MESH" );
3849   createSMESHAction( SMESHOp::OpCreateSubMesh,        "CREATE_SUBMESH",          "ICON_DLG_ADD_SUBMESH" );
3850   createSMESHAction( SMESHOp::OpEditMeshOrSubMesh,    "EDIT_MESHSUBMESH",        "ICON_DLG_EDIT_MESH" );
3851   createSMESHAction( SMESHOp::OpEditMesh,             "EDIT_MESH",               "ICON_DLG_EDIT_MESH" );
3852   createSMESHAction( SMESHOp::OpEditSubMesh,          "EDIT_SUBMESH",            "ICON_DLG_EDIT_MESH" );
3853   createSMESHAction( SMESHOp::OpBuildCompoundMesh,    "BUILD_COMPOUND",          "ICON_BUILD_COMPOUND" );
3854   createSMESHAction( SMESHOp::OpCopyMesh,             "COPY_MESH",               "ICON_COPY_MESH" );
3855   createSMESHAction( SMESHOp::OpCompute,              "COMPUTE",                 "ICON_COMPUTE" );
3856   createSMESHAction( SMESHOp::OpComputeSubMesh,        "COMPUTE_SUBMESH",         "ICON_COMPUTE" );
3857   createSMESHAction( SMESHOp::OpPreCompute,           "PRECOMPUTE",              "ICON_PRECOMPUTE" );
3858   createSMESHAction( SMESHOp::OpEvaluate,             "EVALUATE",                "ICON_EVALUATE" );
3859   createSMESHAction( SMESHOp::OpMeshOrder,            "MESH_ORDER",              "ICON_MESH_ORDER");
3860   createSMESHAction( SMESHOp::OpCreateGroup,          "CREATE_GROUP",            "ICON_CREATE_GROUP" );
3861   createSMESHAction( SMESHOp::OpCreateGeometryGroup,  "CREATE_GEO_GROUP",        "ICON_CREATE_GEO_GROUP" );
3862   createSMESHAction( SMESHOp::OpConstructGroup,       "CONSTRUCT_GROUP",         "ICON_CONSTRUCT_GROUP" );
3863   createSMESHAction( SMESHOp::OpEditGroup,            "EDIT_GROUP",              "ICON_EDIT_GROUP" );
3864   createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3865   createSMESHAction( SMESHOp::OpUnionGroups,          "UN_GROUP",                "ICON_UNION" );
3866   createSMESHAction( SMESHOp::OpIntersectGroups,      "INT_GROUP",               "ICON_INTERSECT" );
3867   createSMESHAction( SMESHOp::OpCutGroups,            "CUT_GROUP",               "ICON_CUT" );
3868   createSMESHAction( SMESHOp::OpGroupUnderlyingElem,  "UNDERLYING_ELEMS",        "ICON_UNDERLYING_ELEMS" );
3869   createSMESHAction( SMESHOp::OpAddElemGroupPopup,    "ADD" );
3870   createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3871   createSMESHAction( SMESHOp::OpDeleteGroup,          "DEL_GROUP",               "ICON_DEL_GROUP" );
3872   createSMESHAction( SMESHOp::OpMeshInformation ,     "ADV_INFO",                "ICON_ADV_INFO" );
3873   //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO",        "ICON_STD_INFO" );
3874   //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3875   createSMESHAction( SMESHOp::OpFindElementByPoint,   "FIND_ELEM",               "ICON_FIND_ELEM" );
3876   //update
3877   createSMESHAction( SMESHOp::OpFreeNode,              "FREE_NODE",               "ICON_FREE_NODE",     0, true );
3878   createSMESHAction( SMESHOp::OpEqualNode,             "EQUAL_NODE",              "ICON_EQUAL_NODE",    0, true );
3879   createSMESHAction( SMESHOp::OpNodeConnectivityNb,    "NODE_CONNECTIVITY_NB",    "ICON_NODE_CONN_NB",    0, true );
3880   createSMESHAction( SMESHOp::OpFreeEdge,              "FREE_EDGE",               "ICON_FREE_EDGE",     0, true );
3881   createSMESHAction( SMESHOp::OpFreeBorder,            "FREE_BORDER",             "ICON_FREE_EDGE_2D",  0, true );
3882   createSMESHAction( SMESHOp::OpLength,                "LENGTH",                  "ICON_LENGTH",        0, true );
3883   createSMESHAction( SMESHOp::OpConnection,            "CONNECTION",              "ICON_CONNECTION",    0, true );
3884   createSMESHAction( SMESHOp::OpEqualEdge,             "EQUAL_EDGE",              "ICON_EQUAL_EDGE",    0, true );
3885   createSMESHAction( SMESHOp::OpFreeFace,              "FREE_FACES",              "ICON_FREE_FACES",    0, true );
3886   createSMESHAction( SMESHOp::OpBareBorderFace,        "BARE_BORDER_FACE",        "ICON_BARE_BORDER_FACE",        0, true );
3887   createSMESHAction( SMESHOp::OpOverConstrainedFace,   "OVER_CONSTRAINED_FACE",   "ICON_OVER_CONSTRAINED_FACE",   0, true );
3888   createSMESHAction( SMESHOp::OpLength2D,              "LENGTH_2D",               "ICON_LENGTH_2D",     0, true );
3889   createSMESHAction( SMESHOp::OpConnection2D,          "CONNECTION_2D",           "ICON_CONNECTION_2D", 0, true );
3890   createSMESHAction( SMESHOp::OpArea,                  "AREA",                    "ICON_AREA",          0, true );
3891   createSMESHAction( SMESHOp::OpTaper,                 "TAPER",                   "ICON_TAPER",         0, true );
3892   createSMESHAction( SMESHOp::OpAspectRatio,           "ASPECT",                  "ICON_ASPECT",        0, true );
3893   createSMESHAction( SMESHOp::OpMinimumAngle,          "MIN_ANG",                 "ICON_ANGLE",         0, true );
3894   createSMESHAction( SMESHOp::OpWarpingAngle,          "WARP",                    "ICON_WARP",          0, true );
3895   createSMESHAction( SMESHOp::OpSkew,                  "SKEW",                    "ICON_SKEW",          0, true );
3896   createSMESHAction( SMESHOp::OpMaxElementLength2D,    "MAX_ELEMENT_LENGTH_2D",   "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
3897   createSMESHAction( SMESHOp::OpEqualFace,             "EQUAL_FACE",              "ICON_EQUAL_FACE",    0, true );
3898   createSMESHAction( SMESHOp::OpAspectRatio3D,         "ASPECT_3D",               "ICON_ASPECT_3D",     0, true );
3899   createSMESHAction( SMESHOp::OpVolume,                "VOLUME_3D",               "ICON_VOLUME_3D",     0, true );
3900   createSMESHAction( SMESHOp::OpMaxElementLength3D,    "MAX_ELEMENT_LENGTH_3D",   "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
3901   createSMESHAction( SMESHOp::OpBareBorderVolume,      "BARE_BORDER_VOLUME",      "ICON_BARE_BORDER_VOLUME",      0, true );
3902   createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3903   createSMESHAction( SMESHOp::OpEqualVolume,           "EQUAL_VOLUME",            "ICON_EQUAL_VOLUME",  0, true );
3904   createSMESHAction( SMESHOp::OpOverallMeshQuality,    "OVERALL_MESH_QUALITY" );
3905
3906   createSMESHAction( SMESHOp::OpNode,                   "NODE",            "ICON_DLG_NODE" );
3907   createSMESHAction( SMESHOp::OpElem0D,                 "ELEM0D",          "ICON_DLG_ELEM0D" );
3908   createSMESHAction( SMESHOp::OpElem0DOnElemNodes,      "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3909   createSMESHAction( SMESHOp::OpBall,                   "BALL",            "ICON_DLG_BALL" );
3910   createSMESHAction( SMESHOp::OpEdge,                   "EDGE",            "ICON_DLG_EDGE" );
3911   createSMESHAction( SMESHOp::OpTriangle,               "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3912   createSMESHAction( SMESHOp::OpQuadrangle,             "QUAD",            "ICON_DLG_QUADRANGLE" );
3913   createSMESHAction( SMESHOp::OpPolygon,                "POLYGON",         "ICON_DLG_POLYGON" );
3914   createSMESHAction( SMESHOp::OpTetrahedron,            "TETRA",           "ICON_DLG_TETRAS" );
3915   createSMESHAction( SMESHOp::OpHexahedron,             "HEXA",            "ICON_DLG_HEXAS" );
3916   createSMESHAction( SMESHOp::OpPentahedron,            "PENTA",           "ICON_DLG_PENTA" );
3917   createSMESHAction( SMESHOp::OpPyramid ,               "PYRAMID",         "ICON_DLG_PYRAMID" );
3918   createSMESHAction( SMESHOp::OpHexagonalPrism,         "OCTA",            "ICON_DLG_OCTA" );
3919   createSMESHAction( SMESHOp::OpPolyhedron,             "POLYHEDRON",      "ICON_DLG_POLYHEDRON" );
3920   createSMESHAction( SMESHOp::OpQuadraticEdge,          "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
3921   createSMESHAction( SMESHOp::OpQuadraticTriangle,      "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
3922   createSMESHAction( SMESHOp::OpBiQuadraticTriangle,    "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3923   createSMESHAction( SMESHOp::OpQuadraticQuadrangle,    "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
3924   createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle,  "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3925   createSMESHAction( SMESHOp::OpQuadraticPolygon,       "QUADRATIC_POLYGON",       "ICON_DLG_QUADRATIC_POLYGON" );
3926   createSMESHAction( SMESHOp::OpQuadraticTetrahedron,   "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3927   createSMESHAction( SMESHOp::OpQuadraticPyramid,       "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
3928   createSMESHAction( SMESHOp::OpQuadraticPentahedron,   "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3929   createSMESHAction( SMESHOp::OpQuadraticHexahedron,    "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3930   createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3931
3932   createSMESHAction( SMESHOp::OpRemoveNodes,       "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
3933   createSMESHAction( SMESHOp::OpRemoveElements,    "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
3934   createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
3935   createSMESHAction( SMESHOp::OpClearMesh,         "CLEAR_MESH",            "ICON_CLEAR_MESH" );
3936
3937   //createSMESHAction( SMESHOp::OpRenumberingNodes,    "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
3938   //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
3939
3940   createSMESHAction( SMESHOp::OpTranslation,            "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
3941   createSMESHAction( SMESHOp::OpRotation,               "ROT",             "ICON_DLG_MESH_ROTATION" );
3942   createSMESHAction( SMESHOp::OpSymmetry,               "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
3943   createSMESHAction( SMESHOp::OpScale,                  "SCALE",           "ICON_DLG_MESH_SCALE" );
3944   createSMESHAction( SMESHOp::OpSewing,                 "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
3945   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
3946   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
3947   createSMESHAction( SMESHOp::OpMoveNode,               "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3948   createSMESHAction( SMESHOp::OpDuplicateNodes,         "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3949   createSMESHAction( SMESHOp::OpDiagonalInversion,      "INV",             "ICON_DLG_MESH_DIAGONAL" );
3950   createSMESHAction( SMESHOp::OpUnionOfTwoTriangle,     "UNION2",          "ICON_UNION2TRI" );
3951   createSMESHAction( SMESHOp::OpOrientation,            "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
3952   createSMESHAction( SMESHOp::OpReorientFaces,          "REORIENT_2D",     "ICON_REORIENT_2D" );
3953   createSMESHAction( SMESHOp::OpUnionOfTriangles,       "UNION",           "ICON_UNIONTRI" );
3954   createSMESHAction( SMESHOp::OpCuttingOfQuadrangles,   "CUT",             "ICON_CUTQUAD" );
3955   createSMESHAction( SMESHOp::OpSplitVolumes,           "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
3956   createSMESHAction( SMESHOp::OpSplitBiQuadratic,       "SPLIT_BIQUAD",    "ICON_SPLIT_BIQUAD" );
3957   createSMESHAction( SMESHOp::OpSmoothing,              "SMOOTH",          "ICON_DLG_SMOOTHING" );
3958   createSMESHAction( SMESHOp::OpExtrusion,              "EXTRUSION",       "ICON_EXTRUSION" );
3959   createSMESHAction( SMESHOp::OpExtrusionAlongAPath,    "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3960   createSMESHAction( SMESHOp::OpRevolution,             "REVOLUTION",      "ICON_REVOLUTION" );
3961   createSMESHAction( SMESHOp::OpPatternMapping,         "MAP",             "ICON_MAP" );
3962   createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
3963   createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
3964
3965   createSMESHAction( SMESHOp::OpReset,               "RESET" );
3966   createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3967   createSMESHAction( SMESHOp::OpShowScalarBar,       "SHOW_SCALAR_BAR","",0, true  );
3968   createSMESHAction( SMESHOp::OpSaveDistribution,    "SAVE_DISTRIBUTION" );
3969   createSMESHAction( SMESHOp::OpShowDistribution,    "SHOW_DISTRIBUTION","",0, true );
3970 #ifndef DISABLE_PLOT2DVIEWER
3971   createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3972 #endif
3973   createSMESHAction( SMESHOp::OpDMWireframe,  "WIRE",    "ICON_WIRE", 0, true );
3974   createSMESHAction( SMESHOp::OpDMShading,    "SHADE",   "ICON_SHADE", 0, true );
3975   createSMESHAction( SMESHOp::OpDMNodes,      "NODES",   "ICON_POINTS", 0, true );
3976   createSMESHAction( SMESHOp::OpDMShrink,     "SHRINK",  "ICON_SHRINK", 0, true );
3977   createSMESHAction( SMESHOp::OpUpdate,       "UPDATE",  "ICON_UPDATE" );
3978   createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3979   createSMESHAction( SMESHOp::OpDEEdges,      "EDGES",   "ICON_DLG_EDGE", 0, true );
3980   createSMESHAction( SMESHOp::OpDEFaces,      "FACES",   "ICON_DLG_TRIANGLE", 0, true );
3981   createSMESHAction( SMESHOp::OpDEVolumes,    "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3982   createSMESHAction( SMESHOp::OpDEBalls,      "BALLS",   "ICON_DLG_BALL", 0, true );
3983   createSMESHAction( SMESHOp::OpDEChoose,     "CHOOSE",  "ICON_DLG_CHOOSE", 0, false );
3984   createSMESHAction( SMESHOp::OpDEAllEntity,  "ALL",     "ICON_DLG_CHOOSE_ALL", 0, false );
3985   createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3986
3987   createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3988   createSMESHAction( SMESHOp::OpRepresentationArcs,  "ARC_REPRESENTATION", "", 0, true );
3989
3990   createSMESHAction( SMESHOp::OpEditHypothesis,    "EDIT_HYPO" );
3991   createSMESHAction( SMESHOp::OpUnassign,          "UNASSIGN" );
3992   createSMESHAction( SMESHOp::OpNumberingNodes,    "NUM_NODES", "", 0, true );
3993   createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3994   createSMESHAction( SMESHOp::OpProperties,   "COLORS" );
3995   createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3996   createSMESHAction( SMESHOp::OpClipping,     "CLIP" );
3997   createSMESHAction( SMESHOp::OpAutoColor,        "AUTO_COLOR" );
3998   createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3999
4000   createSMESHAction( SMESHOp::OpMinimumDistance,  "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4001   createSMESHAction( SMESHOp::OpBoundingBox,      "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
4002   createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH",   "ICON_MEASURE_LENGTH" );
4003   createSMESHAction( SMESHOp::OpPropertiesArea,   "MEASURE_AREA",     "ICON_MEASURE_AREA" );
4004   createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME",   "ICON_MEASURE_VOLUME" );
4005
4006   createSMESHAction( SMESHOp::OpHide,     "HIDE" );
4007   createSMESHAction( SMESHOp::OpShow,     "SHOW" );
4008   createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4009
4010   createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4011
4012   QList<int> aCtrlActions;
4013   aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4014                << SMESHOp::OpNodeConnectivityNb                                         // node controls
4015                << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4016                << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge    // edge controls
4017                << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4018                << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4019                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4020                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4021                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
4022                << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4023                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4024                << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
4025   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4026   aCtrlGroup->setExclusive( true );
4027   for( int i = 0; i < aCtrlActions.size(); i++ )
4028     aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4029
4030   // ----- create menu --------------
4031   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
4032       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
4033       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
4034       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
4035       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
4036       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
4037       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4038       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
4039
4040   createMenu( separator(), fileId );
4041
4042   QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4043   QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4044   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4045       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4046       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4047       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4048       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4049       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4050       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
4051       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4052     //renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
4053       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4054       basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4055
4056   //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4057   createMenu( SMESHOp::OpImportUNV,  importId, -1 );
4058   createMenu( SMESHOp::OpImportMED,  importId, -1 );
4059   createMenu( SMESHOp::OpImportSTL,  importId, -1 );
4060 #ifdef WITH_CGNS
4061   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4062 #endif
4063   createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4064   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
4065   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
4066   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
4067   createMenu( SMESHOp::OpExportUNV,  exportId, -1 );
4068   createMenu( SMESHOp::OpExportSTL,  exportId, -1 );
4069 #ifdef WITH_CGNS
4070   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4071 #endif
4072   createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4073   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
4074   createMenu( separator(), fileId, 10 );
4075
4076   createMenu( SMESHOp::OpDelete, editId, -1 );
4077
4078   createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4079
4080   createMenu( SMESHOp::OpCreateMesh,           meshId, -1 ); // "Mesh" menu
4081   createMenu( SMESHOp::OpCreateSubMesh,        meshId, -1 );
4082   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
4083   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
4084   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
4085   createMenu( separator(),                     meshId, -1 );
4086   createMenu( SMESHOp::OpCompute,              meshId, -1 );
4087   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
4088   createMenu( SMESHOp::OpEvaluate,             meshId, -1 );
4089   createMenu( SMESHOp::OpMeshOrder,            meshId, -1 );
4090   createMenu( separator(),                     meshId, -1 );
4091   createMenu( SMESHOp::OpCreateGroup,          meshId, -1 );
4092   createMenu( SMESHOp::OpCreateGeometryGroup,  meshId, -1 );
4093   createMenu( SMESHOp::OpConstructGroup,       meshId, -1 );
4094   createMenu( SMESHOp::OpEditGroup,            meshId, -1 );
4095   createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4096   createMenu( separator(),                     meshId, -1 );
4097   createMenu( SMESHOp::OpUnionGroups,          meshId, -1 );
4098   createMenu( SMESHOp::OpIntersectGroups,      meshId, -1 );
4099   createMenu( SMESHOp::OpCutGroups,            meshId, -1 );
4100   createMenu( separator(),                     meshId, -1 );
4101   createMenu( SMESHOp::OpGroupUnderlyingElem,  meshId, -1 );
4102   createMenu( separator(),                     meshId, -1 );
4103   createMenu( SMESHOp::OpMeshInformation,      meshId, -1 );
4104   //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4105   //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4106   createMenu( SMESHOp::OpFindElementByPoint,   meshId, -1 );
4107   createMenu( separator(),                     meshId, -1 );
4108
4109   createMenu( SMESHOp::OpFreeNode,              nodeId,   -1 );
4110   createMenu( SMESHOp::OpEqualNode,             nodeId,   -1 );
4111   //createMenu( SMESHOp::OpNodeConnectivityNb,    nodeId,   -1 );
4112   createMenu( SMESHOp::OpFreeBorder,            edgeId,   -1 );
4113   createMenu( SMESHOp::OpLength,                edgeId,   -1 );
4114   createMenu( SMESHOp::OpConnection,            edgeId,   -1 );
4115   createMenu( SMESHOp::OpEqualEdge,             edgeId,   -1 );
4116   createMenu( SMESHOp::OpFreeEdge,              faceId,   -1 );
4117   createMenu( SMESHOp::OpFreeFace,              faceId,   -1 );
4118   createMenu( SMESHOp::OpBareBorderFace,        faceId,   -1 );
4119   createMenu( SMESHOp::OpOverConstrainedFace,   faceId,   -1 );
4120   createMenu( SMESHOp::OpLength2D,              faceId,   -1 );
4121   createMenu( SMESHOp::OpConnection2D,          faceId,   -1 );
4122   createMenu( SMESHOp::OpArea,                  faceId,   -1 );
4123   createMenu( SMESHOp::OpTaper,                 faceId,   -1 );
4124   createMenu( SMESHOp::OpAspectRatio,           faceId,   -1 );
4125   createMenu( SMESHOp::OpMinimumAngle,          faceId,   -1 );
4126   createMenu( SMESHOp::OpWarpingAngle,          faceId,   -1 );
4127   createMenu( SMESHOp::OpSkew,                  faceId,   -1 );
4128   createMenu( SMESHOp::OpMaxElementLength2D,    faceId,   -1 );
4129   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
4130   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
4131   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
4132   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
4133   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
4134   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4135   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
4136   createMenu( separator(),                      ctrlId,   -1 );
4137   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
4138   createMenu( separator(),                      ctrlId,   -1 );
4139   createMenu( SMESHOp::OpOverallMeshQuality,    ctrlId,   -1 );
4140
4141   createMenu( SMESHOp::OpNode,                   addId, -1 );
4142   createMenu( SMESHOp::OpElem0D,                 addId, -1 );
4143   createMenu( SMESHOp::OpElem0DOnElemNodes,      addId, -1 );
4144   createMenu( SMESHOp::OpBall,                   addId, -1 );
4145   createMenu( SMESHOp::OpEdge,                   addId, -1 );
4146   createMenu( SMESHOp::OpTriangle,               addId, -1 );
4147   createMenu( SMESHOp::OpQuadrangle,             addId, -1 );
4148   createMenu( SMESHOp::OpPolygon,                addId, -1 );
4149   createMenu( SMESHOp::OpTetrahedron,            addId, -1 );
4150   createMenu( SMESHOp::OpHexahedron,             addId, -1 );
4151   createMenu( SMESHOp::OpPentahedron,            addId, -1 );
4152   createMenu( SMESHOp::OpPyramid,                addId, -1 );
4153   createMenu( SMESHOp::OpHexagonalPrism,         addId, -1 );
4154   createMenu( SMESHOp::OpPolyhedron,             addId, -1 );
4155   createMenu( separator(),                       addId, -1 );
4156   createMenu( SMESHOp::OpQuadraticEdge,          addId, -1 );
4157   createMenu( SMESHOp::OpQuadraticTriangle,      addId, -1 );
4158   createMenu( SMESHOp::OpBiQuadraticTriangle ,   addId, -1 );
4159   createMenu( SMESHOp::OpQuadraticQuadrangle,    addId, -1 );
4160   createMenu( SMESHOp::OpBiQuadraticQuadrangle,  addId, -1 );
4161   createMenu( SMESHOp::OpQuadraticPolygon,       addId, -1 );
4162   createMenu( SMESHOp::OpQuadraticTetrahedron,   addId, -1 );
4163   createMenu( SMESHOp::OpQuadraticPyramid,       addId, -1 );
4164   createMenu( SMESHOp::OpQuadraticPentahedron,   addId, -1 );
4165   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
4166   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4167
4168   createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
4169   createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
4170   createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4171   createMenu( separator(),                  removeId, -1 );
4172   createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
4173   createMenu( separator(),                  removeId, -1 );
4174   createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
4175
4176   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
4177   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4178
4179   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
4180   createMenu( SMESHOp::OpRotation,       transfId, -1 );
4181   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
4182   createMenu( SMESHOp::OpScale,          transfId, -1 );
4183   createMenu( SMESHOp::OpSewing,         transfId, -1 );
4184   createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
4185   createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
4186   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4187
4188   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
4189   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
4190   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
4191   createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
4192   createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
4193   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
4194   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
4195   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
4196   createMenu( SMESHOp::OpSplitBiQuadratic,       modifyId, -1 );
4197   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
4198   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
4199   createMenu( SMESHOp::OpExtrusionAlongAPath ,   modifyId, -1 );
4200   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
4201   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
4202   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4203   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4204
4205   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
4206   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
4207   createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4208   createMenu( SMESHOp::OpPropertiesArea,   basicPropId, -1 );
4209   createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4210   createMenu( SMESHOp::OpUpdate,           viewId,      -1 );
4211
4212   connect( nodeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4213   connect( edgeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4214   connect( faceMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4215   connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4216
4217   // ----- create toolbars --------------
4218   int meshTb       = createTool( tr( "TB_MESH" ),      QString( "SMESHMeshToolbar" ) ),
4219       info         = createTool( tr( "TB_INFO" ),      QString( "SMESHInformationToolbar" ) ),
4220       groupTb      = createTool( tr( "TB_GROUP" ),     QString( "SMESHGroupToolbar" ) ),
4221       ctrl0dTb     = createTool( tr( "TB_CTRL0D" ),    QString( "SMESHNodeControlsToolbar" ) ),
4222       ctrl1dTb     = createTool( tr( "TB_CTRL1D" ),    QString( "SMESHEdgeControlsToolbar" ) ),
4223       ctrl2dTb     = createTool( tr( "TB_CTRL2D" ),    QString( "SMESHFaceControlsToolbar" ) ),
4224       ctrl3dTb     = createTool( tr( "TB_CTRL3D" ),    QString( "SMESHVolumeControlsToolbar" ) ),
4225       addElemTb    = createTool( tr( "TB_ADD" ),       QString( "SMESHAddElementToolbar" ) ),
4226       addNonElemTb = createTool( tr( "TB_ADDNON" ),    QString( "SMESHAddElementToolbar" ) ),
4227       remTb        = createTool( tr( "TB_REM" ),       QString( "SMESHRemoveToolbar" ) ),
4228     //renumbTb     = createTool( tr( "TB_RENUMBER" ),  QString( "SMESHRenumberingToolbar" ) ),
4229       transformTb  = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4230       modifyTb     = createTool( tr( "TB_MODIFY" ),    QString( "SMESHModificationToolbar" ) ),
4231       measuremTb   = createTool( tr( "TB_MEASUREM" ),  QString( "SMESHMeasurementsToolbar" ) ),
4232       dispModeTb   = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4233
4234   createTool( SMESHOp::OpCreateMesh,        meshTb );
4235   createTool( SMESHOp::OpCreateSubMesh,     meshTb );
4236   createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4237   createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4238   createTool( SMESHOp::OpCopyMesh,          meshTb );
4239   createTool( separator(),                  meshTb );
4240   createTool( SMESHOp::OpCompute,           meshTb );
4241   createTool( SMESHOp::OpPreCompute,        meshTb );
4242   createTool( SMESHOp::OpEvaluate,          meshTb );
4243   createTool( SMESHOp::OpMeshOrder,         meshTb );
4244
4245   createTool( SMESHOp::OpCreateGroup,         groupTb );
4246   createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4247   createTool( SMESHOp::OpConstructGroup,      groupTb );
4248   createTool( SMESHOp::OpEditGroup,           groupTb );
4249
4250   createTool( SMESHOp::OpMeshInformation,    info );
4251   //createTool( SMESHOp::OpStdInfo, meshTb );
4252   //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4253   createTool( SMESHOp::OpFindElementByPoint, info );
4254
4255   createTool( SMESHOp::OpFreeNode,  ctrl0dTb );
4256   createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4257   //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4258
4259   createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4260   createTool( SMESHOp::OpLength,     ctrl1dTb );
4261   createTool( SMESHOp::OpConnection, ctrl1dTb );
4262   createTool( SMESHOp::OpEqualEdge,  ctrl1dTb );
4263
4264   createTool( SMESHOp::OpFreeEdge,            ctrl2dTb );
4265   createTool( SMESHOp::OpFreeFace,            ctrl2dTb );
4266   createTool( SMESHOp::OpBareBorderFace,      ctrl2dTb );
4267   createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4268   createTool( SMESHOp::OpLength2D,            ctrl2dTb );
4269   createTool( SMESHOp::OpConnection2D,        ctrl2dTb );
4270   createTool( SMESHOp::OpArea,                ctrl2dTb );
4271   createTool( SMESHOp::OpTaper,               ctrl2dTb );
4272   createTool( SMESHOp::OpAspectRatio,         ctrl2dTb );
4273   createTool( SMESHOp::OpMinimumAngle,        ctrl2dTb );
4274   createTool( SMESHOp::OpWarpingAngle,        ctrl2dTb );
4275   createTool( SMESHOp::OpSkew,                ctrl2dTb );
4276   createTool( SMESHOp::OpMaxElementLength2D,  ctrl2dTb );
4277   createTool( SMESHOp::OpEqualFace,           ctrl2dTb );
4278
4279   createTool( SMESHOp::OpAspectRatio3D,         ctrl3dTb );
4280   createTool( SMESHOp::OpVolume,                ctrl3dTb );
4281   createTool( SMESHOp::OpMaxElementLength3D,    ctrl3dTb );
4282   createTool( SMESHOp::OpBareBorderVolume,      ctrl3dTb );
4283   createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4284   createTool( SMESHOp::OpEqualVolume,           ctrl3dTb );
4285
4286   createTool( SMESHOp::OpNode,              addElemTb );
4287   createTool( SMESHOp::OpElem0D,            addElemTb );
4288   createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4289   createTool( SMESHOp::OpBall,              addElemTb );
4290   createTool( SMESHOp::OpEdge,              addElemTb );
4291   createTool( SMESHOp::OpTriangle,          addElemTb );
4292   createTool( SMESHOp::OpQuadrangle,        addElemTb );
4293   createTool( SMESHOp::OpPolygon,           addElemTb );
4294   createTool( SMESHOp::OpTetrahedron,       addElemTb );
4295   createTool( SMESHOp::OpHexahedron,        addElemTb );
4296   createTool( SMESHOp::OpPentahedron,       addElemTb );
4297   createTool( SMESHOp::OpPyramid,           addElemTb );
4298   createTool( SMESHOp::OpHexagonalPrism,    addElemTb );
4299   createTool( SMESHOp::OpPolyhedron,        addElemTb );
4300
4301   createTool( SMESHOp::OpQuadraticEdge,          addNonElemTb );
4302   createTool( SMESHOp::OpQuadraticTriangle,      addNonElemTb );
4303   createTool( SMESHOp::OpBiQuadraticTriangle,    addNonElemTb );
4304   createTool( SMESHOp::OpQuadraticQuadrangle,    addNonElemTb );
4305   createTool( SMESHOp::OpBiQuadraticQuadrangle,  addNonElemTb );
4306   createTool( SMESHOp::OpQuadraticPolygon,       addNonElemTb );
4307   createTool( SMESHOp::OpQuadraticTetrahedron,   addNonElemTb );
4308   createTool( SMESHOp::OpQuadraticPyramid,       addNonElemTb );
4309   createTool( SMESHOp::OpQuadraticPentahedron,   addNonElemTb );
4310   createTool( SMESHOp::OpQuadraticHexahedron,    addNonElemTb );
4311   createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4312
4313   createTool( SMESHOp::OpRemoveNodes,       remTb );
4314   createTool( SMESHOp::OpRemoveElements,    remTb );
4315   createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4316   createTool( SMESHOp::OpClearMesh,         remTb );
4317
4318   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
4319   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4320
4321   createTool( SMESHOp::OpTranslation,    transformTb );
4322   createTool( SMESHOp::OpRotation,       transformTb );
4323   createTool( SMESHOp::OpSymmetry,       transformTb );
4324   createTool( SMESHOp::OpScale,          transformTb );
4325   createTool( SMESHOp::OpSewing,         transformTb );
4326   createTool( SMESHOp::OpMergeNodes,     transformTb );
4327   createTool( SMESHOp::OpMergeElements,  transformTb );
4328   createTool( SMESHOp::OpDuplicateNodes, transformTb );
4329
4330   createTool( SMESHOp::OpMoveNode,               modifyTb );
4331   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
4332   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
4333   createTool( SMESHOp::OpOrientation,            modifyTb );
4334   createTool( SMESHOp::OpReorientFaces,          modifyTb );
4335   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
4336   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
4337   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
4338   createTool( SMESHOp::OpSplitBiQuadratic,       modifyTb );
4339   createTool( SMESHOp::OpSmoothing,              modifyTb );
4340   createTool( SMESHOp::OpExtrusion,              modifyTb );
4341   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
4342   createTool( SMESHOp::OpRevolution,             modifyTb );
4343   createTool( SMESHOp::OpPatternMapping,         modifyTb );
4344   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4345   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4346
4347   createTool( SMESHOp::OpMinimumDistance, measuremTb );
4348
4349   createTool( SMESHOp::OpUpdate, dispModeTb );
4350
4351   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4352   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4353
4354   myRules.clear();
4355   QString
4356     OB      = "'ObjectBrowser'",
4357     View    = "'" + SVTK_Viewer::Type() + "'",
4358     pat     = "'%1'",
4359     mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4360     group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4361     hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4362     algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4363     elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4364     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4365     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4366     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4367     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4368     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4369     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4370     subMesh      = elems,
4371     mesh_part    = mesh + " " + subMesh + " " + group,
4372     mesh_group   = mesh + " " + group,
4373     mesh_submesh = mesh + " " + subMesh,
4374     hyp_alg      = hypo + " " + algo;
4375
4376   // popup for object browser
4377   QString
4378     isInvisible("not( isVisible )"),
4379     isEmpty("numberOfNodes = 0"),
4380     isNotEmpty("numberOfNodes <> 0"),
4381
4382     // has nodes, edges, etc in VISIBLE! actor
4383     hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4384     hasElems("(count( elemTypes ) > 0)"),
4385     hasDifferentElems("(count( elemTypes ) > 1)"),
4386     hasBalls("({'BallElem'} in elemTypes)"),
4387     hasElems0d("({'Elem0d'} in elemTypes)"),
4388     hasEdges("({'Edge'} in elemTypes)"),
4389     hasFaces("({'Face'} in elemTypes)"),
4390     hasVolumes("({'Volume'} in elemTypes)"),
4391     hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4392
4393   createPopupItem( SMESHOp::OpFileInformation,   OB, mesh, "&& selcount=1 && isImported" );
4394   createPopupItem( SMESHOp::OpCreateSubMesh,     OB, mesh, "&& hasGeomReference");
4395   createPopupItem( SMESHOp::OpEditMesh,          OB, mesh, "&& selcount=1" );
4396   createPopupItem( SMESHOp::OpEditSubMesh,       OB, subMesh, "&& selcount=1 && hasGeomReference" );
4397   createPopupItem( SMESHOp::OpEditGroup,         OB, group );
4398   createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4399
4400   popupMgr()->insert( separator(), -1, 0 );
4401   createPopupItem( SMESHOp::OpCompute,           OB, mesh, "&& selcount=1 && isComputable" );
4402   createPopupItem( SMESHOp::OpComputeSubMesh,    OB, subMesh, "&& selcount=1 && isComputable" );
4403   createPopupItem( SMESHOp::OpPreCompute,        OB, mesh, "&& selcount=1 && isPreComputable" );
4404   createPopupItem( SMESHOp::OpEvaluate,          OB, mesh, "&& selcount=1 && isComputable" );
4405   createPopupItem( SMESHOp::OpMeshOrder,         OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4406   createPopupItem( SMESHOp::OpUpdate,            OB, mesh_part );
4407   createPopupItem( SMESHOp::OpMeshInformation,   OB, mesh_part );
4408   createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4409   createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4410   popupMgr()->insert( separator(), -1, 0 );
4411   createPopupItem( SMESHOp::OpCreateGroup,       OB, mesh, "&& selcount=1" );
4412   createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4413   createPopupItem( SMESHOp::OpConstructGroup,    OB, subMesh );
4414   popupMgr()->insert( separator(), -1, 0 );
4415   createPopupItem( SMESHOp::OpEditHypothesis,    OB, hypo, "&& isEditableHyp");
4416   createPopupItem( SMESHOp::OpUnassign,          OB, hyp_alg );
4417   popupMgr()->insert( separator(), -1, 0 );
4418   createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4419   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4420   popupMgr()->insert( separator(), -1, 0 );
4421   createPopupItem( SMESHOp::OpClearMesh,              OB, mesh );
4422   //popupMgr()->insert( separator(), -1, 0 );
4423
4424   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4425   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4426   QString only_one_2D        = only_one_non_empty + " && dim>1";
4427
4428   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4429   createPopupItem( SMESHOp::OpPopupExportMED,  OB, mesh_group, multiple_non_empty, anId );
4430   createPopupItem( SMESHOp::OpPopupExportUNV,  OB, mesh_group, only_one_non_empty, anId );
4431   createPopupItem( SMESHOp::OpPopupExportSTL,  OB, mesh_group, only_one_2D, anId );
4432 #ifdef WITH_CGNS
4433   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4434 #endif
4435   createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4436   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, only_one_non_empty, anId );
4437   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, only_one_non_empty, anId );
4438   createPopupItem( SMESHOp::OpDelete,          OB, mesh_part + " " + hyp_alg );
4439   createPopupItem( SMESHOp::OpDeleteGroup,     OB, group );
4440   popupMgr()->insert( separator(), -1, 0 );
4441
4442   // popup for viewer
4443   createPopupItem( SMESHOp::OpEditGroup,            View, group );
4444   createPopupItem( SMESHOp::OpAddElemGroupPopup,    View, elems );
4445   createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4446
4447   popupMgr()->insert( separator(), -1, 0 );
4448   createPopupItem( SMESHOp::OpUpdate,             View, mesh_part );
4449   createPopupItem( SMESHOp::OpMeshInformation,    View, mesh_part );
4450   createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4451   createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4452   popupMgr()->insert( separator(), -1, 0 );
4453
4454   createPopupItem( SMESHOp::OpAutoColor,        OB + " " + View, mesh, "&& (not isAutoColor)" );
4455   createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4456   popupMgr()->insert( separator(), -1, 0 );
4457
4458   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4459   QString aType = QString( "%1type in {%2}" ).arg( lc );
4460   aType = aType.arg( mesh_part );
4461   QString aMeshInVTK = aClient + "&&" + aType;
4462
4463   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4464   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4465   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4466
4467   //-------------------------------------------------
4468   // Numbering
4469   //-------------------------------------------------
4470   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4471
4472   popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4473   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4474   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4475
4476   popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4477   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4478   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4479
4480   popupMgr()->insert( separator(), -1, -1 );
4481
4482   //-------------------------------------------------
4483   // Display Mode
4484   //-------------------------------------------------
4485   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4486
4487   popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4488   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4489   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4490
4491   popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4492   popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4493   popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4494
4495   popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4496   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4497   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4498
4499   popupMgr()->insert( separator(), anId, -1 );
4500
4501   popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4502   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4503   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4504
4505   //-------------------------------------------------
4506   // Display Entity
4507   //-------------------------------------------------
4508   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4509
4510   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4511
4512   popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4513   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4514   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4515
4516   popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4517   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4518   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4519
4520   popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4521   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4522   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4523
4524   popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4525   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4526   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4527
4528   popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4529   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4530   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4531
4532   popupMgr()->insert( separator(), anId, -1 );
4533
4534   popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4535   popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4536
4537   popupMgr()->insert( separator(), anId, -1 );
4538
4539   popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4540   popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4541
4542
4543   //-------------------------------------------------
4544   // Representation of the 2D Quadratic elements
4545   //-------------------------------------------------
4546   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4547   popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4548   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4549   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4550
4551   popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4552   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4553   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4554
4555   //-------------------------------------------------
4556   // Orientation of faces
4557   //-------------------------------------------------
4558   popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4559   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4560   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4561
4562   //-------------------------------------------------
4563   // Color / Size
4564   //-------------------------------------------------
4565   popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4566   popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4567
4568   //-------------------------------------------------
4569   // Transparency
4570   //-------------------------------------------------
4571   popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4572   popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4573
4574   //-------------------------------------------------
4575   // Controls
4576   //-------------------------------------------------
4577   QString
4578     aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4579     aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4580     aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4581     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4582
4583   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4584
4585   popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4586   popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4587
4588   popupMgr()->insert( separator(), anId, -1 );
4589
4590   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4591
4592   popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4593   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4594   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4595
4596   popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4597   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4598   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4599
4600   // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4601   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4602   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4603
4604   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4605
4606   popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4607   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4608   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4609
4610   popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4611   popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4612   popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4613
4614   popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4615   popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4616   popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4617   popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4618   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4619   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4620
4621   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4622
4623   popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4624   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4625   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4626
4627   popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4628   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4629                                        QtxPopupMgr::VisibleRule );
4630   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4631
4632   popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4633   popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4634   popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4635
4636   popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4637   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4638   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4639
4640   popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4641   popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4642   popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4643
4644   popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4645   popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4646   popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4647
4648   popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4649   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4650   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4651
4652   popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4653   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4654   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4655
4656   popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4657   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4658   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4659
4660   popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4661   popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4662   popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4663
4664   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4665   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4666   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4667
4668   popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4669   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4670   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4671
4672   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4673   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4674   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4675   popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4676   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4677   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4678
4679   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4680
4681   popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D  ), aSubId, -1 );
4682   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4683   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4684
4685   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4686   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4687   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4688
4689   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4690   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4691   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4692
4693   popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4694   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4695   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4696
4697   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4698   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4699   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4700
4701   popupMgr()->insert ( action( SMESHOp::OpEqualVolume  ), aSubId, -1 );
4702   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4703   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4704
4705   popupMgr()->insert( separator(), anId, -1 );
4706
4707   popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4708   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4709   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4710   popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4711   popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4712
4713   popupMgr()->insert( separator(), anId, -1 );
4714
4715   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4716
4717   popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4718   popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4719
4720   popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4721   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4722   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4723
4724 #ifndef DISABLE_PLOT2DVIEWER
4725   popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4726   popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4727 #endif
4728
4729   //-------------------------------------------------
4730   // Show / Hide
4731   //-------------------------------------------------
4732   popupMgr()->insert( separator(), -1, -1 );
4733   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4734     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4735   popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4736   popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4737
4738   popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4739   popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4740
4741   popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4742   popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4743
4744   popupMgr()->insert( separator(), -1, -1 );
4745
4746   //-------------------------------------------------
4747   // Clipping
4748   //-------------------------------------------------
4749   popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4750   popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4751
4752   popupMgr()->insert( separator(), -1, -1 );
4753
4754   popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4755   popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4756   popupMgr()->insert( separator(), -1, -1 );
4757
4758   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4759            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4760
4761   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4762            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4763 }
4764
4765 //================================================================================
4766 /*!
4767  * \brief Return true if SMESH or GEOM objects are selected.
4768  * Is called form LightApp_Module::activateModule() which clear selection if
4769  * not isSelectionCompatible()
4770  */
4771 //================================================================================
4772
4773 bool SMESHGUI::isSelectionCompatible()
4774 {
4775   bool isCompatible = true;
4776   SALOME_ListIO selected;
4777   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4778     Sel->selectedObjects( selected );
4779
4780   SALOME_ListIteratorOfListIO It( selected );
4781   for ( ; isCompatible && It.More(); It.Next())
4782     isCompatible =
4783       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4784       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4785
4786   return isCompatible;
4787 }
4788
4789
4790 bool SMESHGUI::reusableOperation( const int id )
4791 {
4792   // compute, evaluate and precompute are not reusable operations
4793   return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4794 }
4795
4796 bool SMESHGUI::activateModule( SUIT_Study* study )
4797 {
4798   bool res = SalomeApp_Module::activateModule( study );
4799
4800   setMenuShown( true );
4801   setToolShown( true );
4802
4803   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4804   PyGILState_STATE gstate = PyGILState_Ensure();
4805   PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4806   if ( !pluginsmanager ) {
4807     PyErr_Print();
4808   }
4809   else {
4810     PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4811     if ( !result )
4812       PyErr_Print();
4813     Py_XDECREF(result);
4814   }
4815   PyGILState_Release(gstate);
4816   // end of SMESH plugins loading
4817
4818   // Reset actions accelerator keys
4819   action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4820
4821   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4822   GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4823   if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4824     if ( _PTR(Study) aStudy = s->studyDS() )
4825       GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4826   }
4827
4828   // get all view currently opened in the study and connect their signals  to
4829   // the corresponding slots of the class.
4830   SUIT_Desktop* aDesk = study->application()->desktop();
4831   if ( aDesk ) {
4832     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4833     SUIT_ViewWindow* wnd;
4834     foreach ( wnd, wndList )
4835       connectView( wnd );
4836   }
4837
4838   Py_XDECREF(pluginsmanager);
4839   return res;
4840 }
4841
4842 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4843 {
4844   setMenuShown( false );
4845   setToolShown( false );
4846
4847   EmitSignalCloseAllDialogs();
4848
4849   // Unset actions accelerator keys
4850   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4851
4852   return SalomeApp_Module::deactivateModule( study );
4853 }
4854
4855 void SMESHGUI::studyClosed( SUIT_Study* s )
4856 {
4857   if( !s )
4858     return;
4859   SMESH::RemoveVisuData( s->id() );
4860   SalomeApp_Module::studyClosed( s );
4861 }
4862
4863 void SMESHGUI::OnGUIEvent()
4864 {
4865   const QObject* obj = sender();
4866   if ( !obj || !obj->inherits( "QAction" ) )
4867     return;
4868   int id = actionId((QAction*)obj);
4869   if ( id != -1 )
4870     OnGUIEvent( id );
4871 }
4872
4873 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4874 {
4875   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4876   if ( CORBA::is_nil( myComponentSMESH ) )
4877     {
4878       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4879       if ( aStudy )
4880         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4881       return aGUI.myComponentSMESH;
4882     }
4883   if ( aStudy )
4884     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4885   return myComponentSMESH;
4886 }
4887
4888 QString SMESHGUI::engineIOR() const
4889 {
4890   CORBA::ORB_var anORB = getApp()->orb();
4891   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4892   return QString( anIOR.in() );
4893 }
4894
4895 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4896 {
4897   SalomeApp_Module::contextMenuPopup( client, menu, title );
4898   SALOME_ListIO lst;
4899   selectionMgr()->selectedObjects( lst );
4900   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4901     Handle(SALOME_InteractiveObject) io = lst.First();
4902     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4903     _PTR(Study) study = appStudy->studyDS();
4904     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4905     if ( obj ) {
4906       QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4907       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4908           aName.remove( (aName.length() - 1), 1 );
4909       title = aName;
4910     }
4911   }
4912 }
4913
4914 LightApp_Selection* SMESHGUI::createSelection() const
4915 {
4916   return new SMESHGUI_Selection();
4917 }
4918
4919 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4920 {
4921   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4922   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4923 #ifndef DISABLE_PYCONSOLE
4924   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4925 #endif
4926 }
4927
4928 void SMESHGUI::viewManagers( QStringList& list ) const
4929 {
4930   list.append( SVTK_Viewer::Type() );
4931 }
4932
4933 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4934 {
4935   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4936     SMESH::UpdateSelectionProp( this );
4937
4938     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4939     for(int i = 0; i < aViews.count() ; i++){
4940       SUIT_ViewWindow *sf = aViews[i];
4941       connectView( sf );
4942     }
4943     EmitSignalActivatedViewManager();
4944   }
4945 }
4946
4947 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4948 {
4949   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4950     myClippingPlaneInfoMap.erase( theViewManager );
4951 }
4952
4953 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4954 {
4955   theActor->AddObserver( SMESH::DeleteActorEvent,
4956                          myEventCallbackCommand.GetPointer(),
4957                          myPriority );
4958 }
4959
4960 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4961                               unsigned long theEvent,
4962                               void* theClientData,
4963                               void* theCallData )
4964 {
4965   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4966     if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4967       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4968         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4969         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4970         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4971           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4972           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4973           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4974             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4975             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4976             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4977             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4978               if( anActor == *anIter3 ) {
4979                 anActorList.erase( anIter3 );
4980                 break;
4981               }
4982             }
4983           }
4984         }
4985       }
4986     }
4987   }
4988 }
4989
4990 void SMESHGUI::createPreferences()
4991 {
4992   // General tab ------------------------------------------------------------------------
4993   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4994
4995   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4996   setPreferenceProperty( autoUpdate, "columns", 2 );
4997   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4998   setPreferenceProperty( lim, "min",  0 );
4999   setPreferenceProperty( lim, "max",  100000000 );
5000   setPreferenceProperty( lim, "step", 1000 );
5001   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5002   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5003
5004   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5005   setPreferenceProperty( qaGroup, "columns", 2 );
5006   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5007   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5008   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5009   setPreferenceProperty( prec, "min", 0 );
5010   setPreferenceProperty( prec, "max", 100 );
5011   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5012   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5013   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5014   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5015   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5016
5017   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5018   setPreferenceProperty( dispgroup, "columns", 2 );
5019   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5020   QStringList modes;
5021   modes.append( tr("MEN_WIRE") );
5022   modes.append( tr("MEN_SHADE") );
5023   modes.append( tr("MEN_NODES") );
5024   modes.append( tr("MEN_SHRINK") );
5025   QList<QVariant> indices;
5026   indices.append( 0 );
5027   indices.append( 1 );
5028   indices.append( 2 );
5029   indices.append( 3 );
5030   setPreferenceProperty( dispmode, "strings", modes );
5031   setPreferenceProperty( dispmode, "indexes", indices );
5032
5033   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5034   setPreferenceProperty( arcgroup, "columns", 2 );
5035   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5036   QStringList quadraticModes;
5037   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5038   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5039   indices.clear();
5040   indices.append( 0 );
5041   indices.append( 1 );
5042   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5043   setPreferenceProperty( quadraticmode, "indexes", indices );
5044
5045   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5046                               "SMESH", "max_angle" );
5047   setPreferenceProperty( maxAngle, "min", 1 );
5048   setPreferenceProperty( maxAngle, "max", 90 );
5049
5050
5051
5052   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5053   setPreferenceProperty( exportgroup, "columns", 2 );
5054   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5055   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5056   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5057
5058   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5059   setPreferenceProperty( computeGroup, "columns", 2 );
5060   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5061   modes.clear();
5062   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5063   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5064   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5065   indices.clear();
5066   indices.append( 0 );
5067   indices.append( 1 );
5068   indices.append( 2 );
5069   setPreferenceProperty( notifyMode, "strings", modes );
5070   setPreferenceProperty( notifyMode, "indexes", indices );
5071
5072   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5073   setPreferenceProperty( infoGroup, "columns", 2 );
5074   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5075   modes.clear();
5076   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5077   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5078   indices.clear();
5079   indices.append( 0 );
5080   indices.append( 1 );
5081   setPreferenceProperty( elemInfo, "strings", modes );
5082   setPreferenceProperty( elemInfo, "indexes", indices );
5083   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5084   setPreferenceProperty( nodesLim, "min", 0 );
5085   setPreferenceProperty( nodesLim, "max", 10000000 );
5086   setPreferenceProperty( nodesLim, "step", 10000 );
5087   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5088   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5089   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5090   setPreferenceProperty( ctrlLim, "min", 0 );
5091   setPreferenceProperty( ctrlLim, "max", 10000000 );
5092   setPreferenceProperty( ctrlLim, "step", 1000 );
5093   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5094   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5095   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5096   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5097   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5098
5099   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5100   setPreferenceProperty( segGroup, "columns", 2 );
5101   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5102                               "SMESH", "segmentation" );
5103   setPreferenceProperty( segLen, "min", 1 );
5104   setPreferenceProperty( segLen, "max", 10000000 );
5105   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5106                              "SMESH", "nb_segments_per_edge" );
5107   setPreferenceProperty( nbSeg, "min", 1 );
5108   setPreferenceProperty( nbSeg, "max", 10000000 );
5109
5110   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5111   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5112                  "SMESH", "forget_mesh_on_hyp_modif" );
5113
5114
5115   // Quantities with individual precision settings
5116   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5117   setPreferenceProperty( precGroup, "columns", 2 );
5118
5119   const int nbQuantities = 6;
5120   int precs[nbQuantities], ii = 0;
5121   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5122                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5123   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5124                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5125   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5126                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5127   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5128                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5129   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5130                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5131   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5132                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5133
5134   // Set property for precision value for spinboxes
5135   for ( ii = 0; ii < nbQuantities; ii++ ){
5136     setPreferenceProperty( precs[ii], "min", -14 );
5137     setPreferenceProperty( precs[ii], "max", 14 );
5138     setPreferenceProperty( precs[ii], "precision", 2 );
5139   }
5140
5141   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5142   setPreferenceProperty( previewGroup, "columns", 2 );
5143   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5144   setPreferenceProperty( chunkSize, "min",  1 );
5145   setPreferenceProperty( chunkSize, "max",  1000 );
5146   setPreferenceProperty( chunkSize, "step", 50 );
5147
5148   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5149   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5150
5151   // Mesh tab ------------------------------------------------------------------------
5152   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5153   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5154   setPreferenceProperty( nodeGroup, "columns", 3 );
5155
5156   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5157
5158   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5159
5160   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5161   QList<QVariant> aMarkerTypeIndicesList;
5162   QList<QVariant> aMarkerTypeIconsList;
5163   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5164     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5165     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5166     aMarkerTypeIndicesList << i;
5167     aMarkerTypeIconsList << pixmap;
5168   }
5169   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5170   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5171
5172   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5173
5174   QList<QVariant> aMarkerScaleIndicesList;
5175   QStringList     aMarkerScaleValuesList;
5176   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5177     aMarkerScaleIndicesList << i;
5178     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5179     aMarkerScaleValuesList  << QString::number( i );
5180   }
5181   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5182   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5183
5184   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5185   //setPreferenceProperty( elemGroup, "columns", 2 );
5186
5187   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5188   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5189   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5190   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5191   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5192   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5193   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5194   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5195   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5196
5197
5198   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5199   setPreferenceProperty( grpGroup, "columns", 2 );
5200
5201   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5202   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5203
5204   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5205                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5206   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5207                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5208   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5209                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5210   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5211                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5212   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5213                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5214   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5215                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5216   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5217                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5218
5219   setPreferenceProperty( size0d, "min", 1 );
5220   setPreferenceProperty( size0d, "max", 10 );
5221
5222  // setPreferenceProperty( ballSize, "min", 1 );
5223  // setPreferenceProperty( ballSize, "max", 10 );
5224
5225   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5226   setPreferenceProperty( ballDiameter, "max", 1e9 );
5227   setPreferenceProperty( ballDiameter, "step", 0.1 );
5228
5229   setPreferenceProperty( ballScale, "min", 1e-2 );
5230   setPreferenceProperty( ballScale, "max", 1e7 );
5231   setPreferenceProperty( ballScale, "step", 0.5 );
5232
5233   setPreferenceProperty( elemW, "min", 1 );
5234   setPreferenceProperty( elemW, "max", 5 );
5235
5236   setPreferenceProperty( outW, "min", 1 );
5237   setPreferenceProperty( outW, "max", 5 );
5238
5239   setPreferenceProperty( shrink, "min", 0 );
5240   setPreferenceProperty( shrink, "max", 100 );
5241
5242   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5243   setPreferenceProperty( numGroup, "columns", 2 );
5244
5245   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5246   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5247
5248   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5249   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5250
5251   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5252   setPreferenceProperty( orientGroup, "columns", 1 );
5253
5254   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5255   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5256
5257   setPreferenceProperty( orientScale, "min", 0.05 );
5258   setPreferenceProperty( orientScale, "max", 0.5 );
5259   setPreferenceProperty( orientScale, "step", 0.05 );
5260
5261   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5262
5263   // Selection tab ------------------------------------------------------------------------
5264   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5265
5266   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5267   setPreferenceProperty( selGroup, "columns", 2 );
5268
5269   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5270   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5271
5272   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5273   setPreferenceProperty( preGroup, "columns", 2 );
5274
5275   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5276
5277   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5278   setPreferenceProperty( precSelGroup, "columns", 2 );
5279
5280   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5281   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5282   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5283
5284   // Scalar Bar tab ------------------------------------------------------------------------
5285   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5286   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5287   setPreferenceProperty( fontGr, "columns", 2 );
5288
5289   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5290   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5291
5292   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5293   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5294
5295   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5296   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5297
5298   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5299   setPreferenceProperty( numcol, "min", 2 );
5300   setPreferenceProperty( numcol, "max", 256 );
5301
5302   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5303   setPreferenceProperty( numlab, "min", 2 );
5304   setPreferenceProperty( numlab, "max", 65 );
5305
5306   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5307   setPreferenceProperty( orientGr, "columns", 2 );
5308   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5309   QStringList orients;
5310   orients.append( tr( "SMESH_VERTICAL" ) );
5311   orients.append( tr( "SMESH_HORIZONTAL" ) );
5312   indices.clear(); indices.append( 0 ); indices.append( 1 );
5313   setPreferenceProperty( orient, "strings", orients );
5314   setPreferenceProperty( orient, "indexes", indices );
5315
5316   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5317   setPreferenceProperty( posVSizeGr, "columns", 2 );
5318   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5319   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5320   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5321   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5322   setPreferenceProperty( xv, "step", 0.1 );
5323   setPreferenceProperty( xv, "min", 0.0 );
5324   setPreferenceProperty( xv, "max", 1.0 );
5325   setPreferenceProperty( yv, "step", 0.1 );
5326   setPreferenceProperty( yv, "min", 0.0 );
5327   setPreferenceProperty( yv, "max", 1.0 );
5328   setPreferenceProperty( wv, "step", 0.1 );
5329   setPreferenceProperty( wv, "min", 0.0 );
5330   setPreferenceProperty( wv, "max", 1.0 );
5331   setPreferenceProperty( hv, "min", 0.0 );
5332   setPreferenceProperty( hv, "max", 1.0 );
5333   setPreferenceProperty( hv, "step", 0.1 );
5334
5335   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5336   setPreferenceProperty( posHSizeGr, "columns", 2 );
5337   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5338   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5339   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5340   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5341   setPreferenceProperty( xv, "min", 0.0 );
5342   setPreferenceProperty( xv, "max", 1.0 );
5343   setPreferenceProperty( xv, "step", 0.1 );
5344   setPreferenceProperty( xh, "min", 0.0 );
5345   setPreferenceProperty( xh, "max", 1.0 );
5346   setPreferenceProperty( xh, "step", 0.1 );
5347   setPreferenceProperty( yh, "min", 0.0 );
5348   setPreferenceProperty( yh, "max", 1.0 );
5349   setPreferenceProperty( yh, "step", 0.1 );
5350   setPreferenceProperty( wh, "min", 0.0 );
5351   setPreferenceProperty( wh, "max", 1.0 );
5352   setPreferenceProperty( wh, "step", 0.1 );
5353   setPreferenceProperty( hh, "min", 0.0 );
5354   setPreferenceProperty( hh, "max", 1.0 );
5355   setPreferenceProperty( hh, "step", 0.1 );
5356
5357   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5358   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5359   setPreferenceProperty( distributionGr, "columns", 3 );
5360   QStringList types;
5361   types.append( tr( "SMESH_MONOCOLOR" ) );
5362   types.append( tr( "SMESH_MULTICOLOR" ) );
5363   indices.clear(); indices.append( 0 ); indices.append( 1 );
5364   setPreferenceProperty( coloringType, "strings", types );
5365   setPreferenceProperty( coloringType, "indexes", indices );
5366   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5367
5368 }
5369
5370 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5371 {
5372   if ( sect=="SMESH" ) {
5373     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5374     float aTol = 1.00000009999999;
5375     std::string aWarning;
5376     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5377
5378     if ( name== "selection_object_color" ||
5379          name=="selection_element_color" ||
5380          name==        "highlight_color" ||
5381          name=="selection_precision_node"    ||
5382          name=="selection_precision_element" ||
5383          name=="selection_precision_object"   )
5384     {
5385       SMESH::UpdateSelectionProp( this );
5386     }
5387     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5388     {
5389       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5390       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5391       if ( sbX1+sbW > aTol ) {
5392         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5393         sbX1 = 0.01;
5394         sbW  = 0.08;
5395         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5396         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5397       }
5398     }
5399     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5400     {
5401       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5402       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5403       if ( sbY1 + sbH > aTol ) {
5404         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5405         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5406         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5407       }
5408     }
5409     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5410     {
5411       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5412       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5413       if ( sbX1 + sbW > aTol ) {
5414         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5415         sbX1=0.1;
5416         sbW =0.08;
5417         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5418         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5419       }
5420     }
5421     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5422     {
5423       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5424       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5425       if ( sbY1 + sbH > aTol ) {
5426         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5427         sbY1=0.01;
5428         sbH =0.08;
5429         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5430         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5431       }
5432     }
5433     else if ( name == "segmentation" )
5434     {
5435       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5436       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5437     }
5438     else if ( name == "nb_segments_per_edge" )
5439     {
5440       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5441       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5442     }
5443     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5444     {
5445       QString val = aResourceMgr->stringValue( "SMESH", name );
5446       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5447     }
5448     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5449     {
5450       SMESH::UpdateFontProp( this );
5451     }
5452     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5453     {
5454       SMESH::UpdateFontProp( this );
5455     }
5456
5457     if ( aWarning.size() != 0 ) {
5458       aWarning += "The default values are applied instead.";
5459       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5460                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5461                                QObject::tr(aWarning.c_str()));
5462     }
5463   }
5464 }
5465
5466 //================================================================================
5467 /*!
5468  * \brief Update something in accordance with update flags
5469   * \param theFlags - update flags
5470 *
5471 * Update viewer or/and object browser etc. in accordance with update flags ( see
5472 * LightApp_UpdateFlags enumeration ).
5473 */
5474 //================================================================================
5475 void SMESHGUI::update( const int flags )
5476 {
5477   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5478     SMESH::UpdateView();
5479   else
5480     SalomeApp_Module::update( flags );
5481 }
5482
5483 //================================================================================
5484 /*!
5485  * \brief Set default selection mode
5486 *
5487 * SLOT called when operation commited. Sets default selection mode
5488 */
5489 //================================================================================
5490 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5491 {
5492   SVTK_ViewWindow* vtkWnd =
5493     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5494   if ( vtkWnd )
5495     vtkWnd->SetSelectionMode( ActorSelection );
5496 }
5497
5498 //================================================================================
5499 /*!
5500  * \brief Set default selection mode
5501 *
5502 * SLOT called when operation aborted. Sets default selection mode
5503 */
5504 //================================================================================
5505 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5506 {
5507   SVTK_ViewWindow* vtkWnd =
5508     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5509   if ( vtkWnd )
5510     vtkWnd->SetSelectionMode( ActorSelection );
5511 }
5512
5513 //================================================================================
5514 /*!
5515  * \brief Creates operation with given identifier
5516   * \param id - identifier of operation to be started
5517   * \return Pointer on created operation or NULL if operation is not created
5518 *
5519 * Virtual method redefined from the base class creates operation with given id.
5520 * It is called called automatically from startOperation method of base class.
5521 */
5522 //================================================================================
5523 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5524 {
5525   LightApp_Operation* op = 0;
5526   // to do : create operation here
5527   switch( id )
5528   {
5529     case SMESHOp::OpSplitBiQuadratic:
5530       op = new SMESHGUI_SplitBiQuadOp();
5531     break;
5532     case SMESHOp::OpConvertMeshToQuadratic:
5533       op = new SMESHGUI_ConvToQuadOp();
5534     break;
5535     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5536       op = new SMESHGUI_Make2DFrom3DOp();
5537     break;
5538     case SMESHOp::OpReorientFaces:
5539       op = new SMESHGUI_ReorientFacesOp();
5540       break;
5541     case SMESHOp::OpCreateMesh:
5542       op = new SMESHGUI_MeshOp( true, true );
5543     break;
5544     case SMESHOp::OpCreateSubMesh:
5545       op = new SMESHGUI_MeshOp( true, false );
5546     break;
5547     case SMESHOp::OpEditMeshOrSubMesh:
5548     case SMESHOp::OpEditMesh:
5549     case SMESHOp::OpEditSubMesh:
5550       op = new SMESHGUI_MeshOp( false );
5551     break;
5552     case SMESHOp::OpCompute:
5553     case SMESHOp::OpComputeSubMesh:
5554       op = new SMESHGUI_ComputeOp();
5555     break;
5556     case SMESHOp::OpPreCompute:
5557       op = new SMESHGUI_PrecomputeOp();
5558     break;
5559     case SMESHOp::OpEvaluate:
5560       op = new SMESHGUI_EvaluateOp();
5561     break;
5562     case SMESHOp::OpMeshOrder:
5563       op = new SMESHGUI_MeshOrderOp();
5564     break;
5565     case SMESHOp::OpCreateGeometryGroup:
5566       op = new SMESHGUI_GroupOnShapeOp();
5567       break;
5568     case SMESHOp::OpFindElementByPoint:
5569       op = new SMESHGUI_FindElemByPointOp();
5570       break;
5571     case SMESHOp::OpMoveNode: // Make mesh pass through point
5572       op = new SMESHGUI_MakeNodeAtPointOp();
5573       break;
5574     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5575       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5576       break;
5577     default:
5578     break;
5579   }
5580
5581   if( !op )
5582     op = SalomeApp_Module::createOperation( id );
5583   return op;
5584 }
5585
5586 //================================================================================
5587 /*!
5588  * \brief Stops current operations and starts a given one
5589   * \param id - The id of the operation to start
5590  */
5591 //================================================================================
5592
5593 void SMESHGUI::switchToOperation(int id)
5594 {
5595   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5596     activeStudy()->abortAllOperations();
5597   startOperation( id );
5598 }
5599
5600 LightApp_Displayer* SMESHGUI::displayer()
5601 {
5602   if( !myDisplayer )
5603     myDisplayer = new SMESHGUI_Displayer( getApp() );
5604   return myDisplayer;
5605 }
5606
5607 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5608 {
5609   int aHue = -1;
5610   int aTolerance = 64;
5611   int anIterations = 0;
5612   int aPeriod = 5;
5613
5614   while( 1 )
5615   {
5616     anIterations++;
5617     if( anIterations % aPeriod == 0 )
5618     {
5619       aTolerance /= 2;
5620       if( aTolerance < 1 )
5621         break;
5622     }
5623
5624     aHue = (int)( 360.0 * rand() / RAND_MAX );
5625
5626     bool ok = true;
5627     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5628     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5629     for( ; it != itEnd; ++it )
5630     {
5631       SALOMEDS::Color anAutoColor = *it;
5632       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5633
5634       int h, s, v;
5635       aQColor.getHsv( &h, &s, &v );
5636       if( abs( h - aHue ) < aTolerance )
5637       {
5638         ok = false;
5639         break;
5640       }
5641     }
5642
5643     if( ok )
5644       break;
5645   }
5646
5647   QColor aColor;
5648   aColor.setHsv( aHue, 255, 255 );
5649
5650   SALOMEDS::Color aSColor;
5651   aSColor.R = aColor.redF();
5652   aSColor.G = aColor.greenF();
5653   aSColor.B = aColor.blueF();
5654
5655   return aSColor;
5656 }
5657
5658 const char* gSeparator = "_"; // character used to separate parameter names
5659 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5660 const char* gPathSep   = "|"; // character used to separate paths
5661
5662 /*!
5663  * \brief Store visual parameters
5664  *
5665  * This method is called just before the study document is saved.
5666  * Store visual parameters in AttributeParameter attribue(s)
5667  */
5668 void SMESHGUI::storeVisualParameters (int savePoint)
5669 {
5670   // localizing
5671   Kernel_Utils::Localizer loc;
5672
5673   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5674   if (!appStudy || !appStudy->studyDS())
5675     return;
5676   _PTR(Study) studyDS = appStudy->studyDS();
5677
5678   // componentName is used for encoding of entries when storing them in IParameters
5679   std::string componentName = myComponentSMESH->ComponentDataType();
5680   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5681   //if (!aSComponent) return;
5682
5683   // IParameters
5684   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5685                                                              componentName.c_str(),
5686                                                              savePoint);
5687   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5688
5689   // store map of custom markers
5690   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5691   if( !aMarkerMap.empty() )
5692   {
5693     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5694     for( ; anIter != aMarkerMap.end(); anIter++ )
5695     {
5696       int anId = anIter->first;
5697       VTK::MarkerData aMarkerData = anIter->second;
5698       std::string aMarkerFileName = aMarkerData.first;
5699       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5700       if( aMarkerTexture.size() < 3 )
5701         continue; // should contain at least width, height and the first value
5702
5703       QString aPropertyName( "texture" );
5704       aPropertyName += gSeparator;
5705       aPropertyName += QString::number( anId );
5706
5707       QString aPropertyValue = aMarkerFileName.c_str();
5708       aPropertyValue += gPathSep;
5709
5710       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5711       ushort aWidth = *aTextureIter++;
5712       ushort aHeight = *aTextureIter++;
5713       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5714       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5715       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5716         aPropertyValue += QString::number( *aTextureIter );
5717
5718       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5719     }
5720   }
5721
5722   // viewers counters are used for storing view_numbers in IParameters
5723   int vtkViewers = 0;
5724
5725   // main cycle to store parameters of displayed objects
5726   QList<SUIT_ViewManager*> lst;
5727   QList<SUIT_ViewManager*>::Iterator it;
5728   getApp()->viewManagers(lst);
5729   for (it = lst.begin(); it != lst.end(); it++)
5730   {
5731     SUIT_ViewManager* vman = *it;
5732     QString vType = vman->getType();
5733
5734     // saving VTK actors properties
5735     if (vType == SVTK_Viewer::Type())
5736     {
5737       // store the clipping planes attached to the view manager
5738       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5739       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5740       if( anIter != myClippingPlaneInfoMap.end() )
5741         aClippingPlaneInfoList = anIter->second;
5742
5743       if( !aClippingPlaneInfoList.empty() ) {
5744         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5745         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5746         {
5747           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5748           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5749
5750           QString aPropertyName( "ClippingPlane" );
5751           aPropertyName += gSeparator;
5752           aPropertyName += QString::number( vtkViewers );
5753           aPropertyName += gSeparator;
5754           aPropertyName += QString::number( anId );
5755
5756           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5757           aPropertyValue += gDigitsSep;
5758           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5759           aPropertyValue += gDigitsSep;
5760           if ( aPlane->PlaneMode == SMESH::Absolute ) {
5761             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5762             aPropertyValue += gDigitsSep;
5763             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5764             aPropertyValue += gDigitsSep;
5765             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5766             aPropertyValue += gDigitsSep;
5767             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5768             aPropertyValue += gDigitsSep;
5769             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5770             aPropertyValue += gDigitsSep;
5771             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5772             aPropertyValue += gDigitsSep;
5773             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5774           }
5775           else if ( aPlane->PlaneMode == SMESH::Relative ) {
5776             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5777             aPropertyValue += gDigitsSep;
5778             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5779             aPropertyValue += gDigitsSep;
5780             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5781             aPropertyValue += gDigitsSep;
5782             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5783           }
5784
5785           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5786         }
5787       }
5788
5789       QVector<SUIT_ViewWindow*> views = vman->getViews();
5790       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5791       {
5792         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5793         {
5794           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5795           vtkActorCollection* allActors = aCopy.GetActors();
5796           allActors->InitTraversal();
5797           while (vtkActor* actor = allActors->GetNextActor())
5798           {
5799             if (actor->GetVisibility()) // store only visible actors
5800             {
5801               SMESH_Actor* aSmeshActor = 0;
5802               if (actor->IsA("SMESH_Actor"))
5803                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5804               if (aSmeshActor && aSmeshActor->hasIO())
5805               {
5806                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5807                 if (io->hasEntry())
5808                 {
5809                   // entry is "encoded" = it does NOT contain component adress,
5810                   // since it is a subject to change on next component loading
5811                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5812
5813                   std::string param, vtkParam = vType.toLatin1().data();
5814                   vtkParam += gSeparator;
5815                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5816                   vtkParam += gSeparator;
5817
5818                   // Visibility
5819                   param = vtkParam + "Visibility";
5820                   ip->setParameter(entry, param, "On");
5821
5822                   // Representation
5823                   param = vtkParam + "Representation";
5824                   ip->setParameter(entry, param, QString::number
5825                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5826
5827                   // IsShrunk
5828                   param = vtkParam + "IsShrunk";
5829                   ip->setParameter(entry, param, QString::number
5830                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5831
5832                   // Displayed entities
5833                   unsigned int aMode = aSmeshActor->GetEntityMode();
5834                   bool isE  = aMode & SMESH_Actor::eEdges;
5835                   bool isF  = aMode & SMESH_Actor::eFaces;
5836                   bool isV  = aMode & SMESH_Actor::eVolumes;
5837                   bool is0d = aMode & SMESH_Actor::e0DElements;
5838                   bool isB  = aMode & SMESH_Actor::eBallElem;
5839
5840                   QString modeStr ("e");
5841                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5842                   modeStr += gDigitsSep; modeStr += "f";
5843                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5844                   modeStr += gDigitsSep; modeStr += "v";
5845                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5846                   modeStr += gDigitsSep; modeStr += "0d";
5847                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5848                   modeStr += gDigitsSep; modeStr += "b";
5849                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5850
5851                   param = vtkParam + "Entities";
5852                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5853
5854                   // Colors
5855                   double r, g, b;
5856                   int delta;
5857
5858                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5859                   QStringList colorStr;
5860                   colorStr << "surface";
5861                   colorStr << QString::number(r);
5862                   colorStr << QString::number(g);
5863                   colorStr << QString::number(b);
5864
5865                   colorStr << "backsurface";
5866                   colorStr << QString::number(delta);
5867
5868                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5869                   colorStr << "volume";
5870                   colorStr << QString::number(r);
5871                   colorStr << QString::number(g);
5872                   colorStr << QString::number(b);
5873                   colorStr << QString::number(delta);
5874
5875                   aSmeshActor->GetEdgeColor(r, g, b);
5876                   colorStr << "edge";
5877                   colorStr << QString::number(r);
5878                   colorStr << QString::number(g);
5879                   colorStr << QString::number(b);
5880
5881                   aSmeshActor->GetNodeColor(r, g, b);
5882                   colorStr << "node";
5883                   colorStr << QString::number(r);
5884                   colorStr << QString::number(g);
5885                   colorStr << QString::number(b);
5886
5887                   aSmeshActor->GetOutlineColor(r, g, b);
5888                   colorStr << "outline";
5889                   colorStr << QString::number(r);
5890                   colorStr << QString::number(g);
5891                   colorStr << QString::number(b);
5892
5893                   aSmeshActor->Get0DColor(r, g, b);
5894                   colorStr << "elem0d";
5895                   colorStr << QString::number(r);
5896                   colorStr << QString::number(g);
5897                   colorStr << QString::number(b);
5898
5899                   aSmeshActor->GetBallColor(r, g, b);
5900                   colorStr << "ball";
5901                   colorStr << QString::number(r);
5902                   colorStr << QString::number(g);
5903                   colorStr << QString::number(b);
5904
5905                   aSmeshActor->GetFacesOrientationColor(r, g, b);
5906                   colorStr << "orientation";
5907                   colorStr << QString::number(r);
5908                   colorStr << QString::number(g);
5909                   colorStr << QString::number(b);
5910
5911                   param = vtkParam + "Colors";
5912                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5913
5914                   // Sizes
5915                   QStringList sizeStr;
5916                   sizeStr << "line";
5917                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5918                   sizeStr << "outline";
5919                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5920                   sizeStr << "elem0d";
5921                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5922                   sizeStr << "ball";
5923                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5924                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5925                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5926                   sizeStr << "shrink";
5927                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5928                   sizeStr << "orientation";
5929                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5930                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5931
5932                   param = vtkParam + "Sizes";
5933                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5934
5935                   // Point marker
5936                   QString markerStr;
5937
5938                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5939                   if( aMarkerType == VTK::MT_USER ) {
5940                     markerStr += "custom";
5941                     markerStr += gDigitsSep;
5942                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5943                   }
5944                   else {
5945                     markerStr += "std";
5946                     markerStr += gDigitsSep;
5947                     markerStr += QString::number( (int)aMarkerType );
5948                     markerStr += gDigitsSep;
5949                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5950                   }
5951
5952                   param = vtkParam + "PointMarker";
5953                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5954
5955                   // Opacity
5956                   param = vtkParam + "Opacity";
5957                   ip->setParameter(entry, param,
5958                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5959
5960                   // Clipping
5961                   param = vtkParam + "ClippingPlane";
5962                   int aPlaneId = 0;
5963                   if( !aClippingPlaneInfoList.empty() ) {
5964                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5965                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5966                     {
5967                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5968                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5969                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5970                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5971                         if( aSmeshActor == *anIter2 ) {
5972                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5973                                             QString::number( anId ).toLatin1().constData() );
5974                           break;
5975                         }
5976                       }
5977                     }
5978                   }
5979                   if( aPlaneId == 0 )
5980                     ip->setParameter( entry, param, "Off" );
5981                 } // if (io->hasEntry())
5982               } // SMESH_Actor && hasIO
5983             } // isVisible
5984           } // while.. actors traversal
5985         } // if (vtkView)
5986       } // for (views)
5987       vtkViewers++;
5988     } // if (SVTK view model)
5989   } // for (viewManagers)
5990 }
5991
5992 // data structures for clipping planes processing
5993 typedef struct {
5994   int Id;
5995   int Mode;
5996   bool isOpenGLClipping;
5997   vtkIdType RelativeOrientation;
5998   double Distance;
5999   double Angle[2];
6000   int AbsoluteOrientation;
6001   double X, Y, Z, Dx, Dy, Dz;
6002 } TPlaneData;
6003 typedef std::list<TPlaneData>         TPlaneDataList;
6004 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6005
6006 typedef std::list<vtkActor*>          TActorList;
6007 typedef struct {
6008   int PlaneId;
6009   TActorList ActorList;
6010   SUIT_ViewManager* ViewManager;
6011 } TPlaneInfo;
6012 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6013 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6014
6015 /*!
6016  * \brief Restore visual parameters
6017  *
6018  * This method is called after the study document is opened.
6019  * Restore visual parameters from AttributeParameter attribue(s)
6020  */
6021 void SMESHGUI::restoreVisualParameters (int savePoint)
6022 {
6023   // localizing
6024   Kernel_Utils::Localizer loc;
6025
6026   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6027   if (!appStudy || !appStudy->studyDS())
6028     return;
6029   _PTR(Study) studyDS = appStudy->studyDS();
6030
6031   // componentName is used for encoding of entries when storing them in IParameters
6032   std::string componentName = myComponentSMESH->ComponentDataType();
6033   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6034   //if (!aSComponent) return;
6035
6036   // IParameters
6037   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6038                                                              componentName.c_str(),
6039                                                              savePoint);
6040   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6041
6042   // restore map of custom markers and map of clipping planes
6043   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6044   TPlaneDataMap aPlaneDataMap;
6045
6046   std::vector<std::string> properties = ip->getProperties();
6047   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6048   {
6049     std::string property = *propIt;
6050     QString aPropertyName( property.c_str() );
6051     QString aPropertyValue( ip->getProperty( property ).c_str() );
6052
6053     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6054     if( aPropertyNameList.isEmpty() )
6055       continue;
6056
6057     QString aPropertyType = aPropertyNameList[0];
6058     if( aPropertyType == "texture" )
6059     {
6060       if( aPropertyNameList.size() != 2 )
6061         continue;
6062
6063       bool ok = false;
6064       int anId = aPropertyNameList[1].toInt( &ok );
6065       if( !ok || anId < 1 )
6066         continue;
6067
6068       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6069       if( aPropertyValueList.size() != 2 )
6070         continue;
6071
6072       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6073       QString aMarkerTextureString = aPropertyValueList[1];
6074       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6075       if( aMarkerTextureStringList.size() != 3 )
6076         continue;
6077
6078       ok = false;
6079       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6080       if( !ok )
6081         continue;
6082
6083       ok = false;
6084       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6085       if( !ok )
6086         continue;
6087
6088       VTK::MarkerTexture aMarkerTexture;
6089       aMarkerTexture.push_back( aWidth );
6090       aMarkerTexture.push_back( aHeight );
6091
6092       QString aMarkerTextureData = aMarkerTextureStringList[2];
6093       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6094       {
6095         QChar aChar = aMarkerTextureData.at( i );
6096         if( aChar.isDigit() )
6097           aMarkerTexture.push_back( aChar.digitValue() );
6098       }
6099
6100       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6101     }
6102     else if( aPropertyType == "ClippingPlane" )
6103     {
6104       if( aPropertyNameList.size() != 3 )
6105         continue;
6106
6107       bool ok = false;
6108       int aViewId = aPropertyNameList[1].toInt( &ok );
6109       if( !ok || aViewId < 0 )
6110         continue;
6111
6112       ok = false;
6113       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6114       if( !ok || aClippingPlaneId < 0 )
6115         continue;
6116
6117       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6118       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6119         continue;
6120
6121       TPlaneData aPlaneData;
6122       aPlaneData.AbsoluteOrientation = false;
6123       aPlaneData.RelativeOrientation = 0;
6124       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6125       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6126       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6127
6128       aPlaneData.Id = aClippingPlaneId;
6129
6130       ok = false;
6131       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6132       if( !ok )
6133         continue;
6134
6135       ok = false;
6136       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6137       if( !ok )
6138         continue;
6139
6140       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6141       {
6142         ok = false;
6143         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6144         if( !ok )
6145           continue;
6146
6147         ok = false;
6148         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6149         if( !ok )
6150           continue;
6151
6152         ok = false;
6153         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6154         if( !ok )
6155           continue;
6156
6157         ok = false;
6158         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6159         if( !ok )
6160           continue;
6161
6162         ok = false;
6163         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6164         if( !ok )
6165           continue;
6166
6167         ok = false;
6168         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6169         if( !ok )
6170           continue;
6171
6172         ok = false;
6173         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6174         if( !ok )
6175           continue;
6176       }
6177       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6178         ok = false;
6179         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6180         if( !ok )
6181           continue;
6182
6183         ok = false;
6184         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6185         if( !ok )
6186           continue;
6187
6188         ok = false;
6189         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6190         if( !ok )
6191           continue;
6192
6193         ok = false;
6194         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6195         if( !ok )
6196           continue;
6197       }
6198
6199       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6200       aPlaneDataList.push_back( aPlaneData );
6201     }
6202   }
6203
6204   TPlaneInfoMap aPlaneInfoMap;
6205
6206   std::vector<std::string> entries = ip->getEntries();
6207
6208   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6209   {
6210     // entry is a normal entry - it should be "decoded" (setting base adress of component)
6211     QString entry (ip->decodeEntry(*entIt).c_str());
6212
6213     // Check that the entry corresponds to a real object in the Study
6214     // as the object may be deleted or modified after the visual state is saved.
6215     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6216     if (!so) continue; //Skip the not existent entry
6217
6218     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6219     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6220
6221     std::vector<std::string>::iterator namesIt = paramNames.begin();
6222     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6223
6224     // actors are stored in a map after displaying of them for
6225     // quicker access in the future: map < viewID to actor >
6226     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6227
6228     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6229     {
6230       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6231       // '_' is used as separator and should not be used in viewer type or parameter names.
6232       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6233       if (lst.size() != 3)
6234         continue;
6235
6236       QString viewerTypStr = lst[0];
6237       QString viewIndexStr = lst[1];
6238       QString paramNameStr = lst[2];
6239
6240       bool ok;
6241       int viewIndex = viewIndexStr.toUInt(&ok);
6242       if (!ok) // bad conversion of view index to integer
6243         continue;
6244
6245       // viewers
6246       if (viewerTypStr == SVTK_Viewer::Type())
6247       {
6248         SMESH_Actor* aSmeshActor = 0;
6249         if (vtkActors.IsBound(viewIndex))
6250           aSmeshActor = vtkActors.Find(viewIndex);
6251
6252         QList<SUIT_ViewManager*> lst;
6253         getApp()->viewManagers(viewerTypStr, lst);
6254
6255         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6256         SUIT_ViewManager* vman = NULL;
6257         if (viewIndex >= 0 && viewIndex < lst.count())
6258           vman = lst.at(viewIndex);
6259
6260         if (paramNameStr == "Visibility")
6261         {
6262           if (!aSmeshActor && displayer() && vman)
6263           {
6264             SUIT_ViewModel* vmodel = vman->getViewModel();
6265             // SVTK view model can be casted to SALOME_View
6266             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6267
6268             // store displayed actor in a temporary map for quicker
6269             // access later when restoring other parameters
6270             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6271             vtkRenderer* Renderer = vtkView->getRenderer();
6272             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6273             vtkActorCollection* theActors = aCopy.GetActors();
6274             theActors->InitTraversal();
6275             bool isFound = false;
6276             vtkActor *ac = theActors->GetNextActor();
6277             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6278               if (ac->IsA("SMESH_Actor")) {
6279                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6280                 if (aGeomAc->hasIO()) {
6281                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6282                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6283                     isFound = true;
6284                     vtkActors.Bind(viewIndex, aGeomAc);
6285                   }
6286                 }
6287               }
6288             }
6289           }
6290         } // if (paramNameStr == "Visibility")
6291         else
6292         {
6293           // the rest properties "work" with SMESH_Actor
6294           if (aSmeshActor)
6295           {
6296             QString val ((*valuesIt).c_str());
6297
6298             // Representation
6299             if (paramNameStr == "Representation") {
6300               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6301             }
6302             // IsShrunk
6303             else if (paramNameStr == "IsShrunk") {
6304               if (val.toInt()) {
6305                 if (!aSmeshActor->IsShrunk())
6306                   aSmeshActor->SetShrink();
6307               }
6308               else {
6309                 if (aSmeshActor->IsShrunk())
6310                   aSmeshActor->UnShrink();
6311               }
6312             }
6313             // Displayed entities
6314             else if (paramNameStr == "Entities") {
6315               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6316               int aEntityMode = SMESH_Actor::eAllEntity;
6317               for ( int i = 0; i < mode.count(); i+=2 ) {
6318                 if ( i < mode.count()-1 ) {
6319                   QString type = mode[i];
6320                   bool val = mode[i+1].toInt();
6321                   if      ( type == "e" && !val )
6322                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6323                   else if ( type == "f" && !val )
6324                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6325                   else if ( type == "v" && !val )
6326                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6327                   else if ( type == "0d" && !val )
6328                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6329                   else if ( type == "b" && !val )
6330                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6331                 }
6332               }
6333               aSmeshActor->SetEntityMode( aEntityMode );
6334             }
6335             // Colors
6336             else if (paramNameStr == "Colors") {
6337               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6338               QColor nodeColor;
6339               QColor edgeColor;
6340               QColor faceColor;
6341               QColor volumeColor;
6342               QColor elem0dColor;
6343               QColor ballColor;
6344               QColor outlineColor;
6345               QColor orientationColor;
6346               int deltaF;
6347               int deltaV;
6348               QColor c;
6349               double r, g, b;
6350               bool bOk;
6351               // below lines are required to get default values for delta coefficients
6352               // of backface color for faces and color of reversed volumes
6353               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6354               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6355               for ( int i = 0; i < colors.count(); i++ ) {
6356                 QString type = colors[i];
6357                 if ( type == "surface" ) {
6358                   // face color is set by 3 values r:g:b, where
6359                   // - r,g,b - is rgb color components
6360                   if ( i+1 >= colors.count() ) break;                  // format error
6361                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6362                   if ( i+2 >= colors.count() ) break;                  // format error
6363                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6364                   if ( i+3 >= colors.count() ) break;                  // format error
6365                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6366                   faceColor.setRgbF( r, g, b );
6367                   i += 3;
6368                 }
6369                 else if ( type == "backsurface" ) {
6370                   // backface color can be defined in several ways
6371                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6372                   // - in latest versions, it is set as delta coefficient
6373                   bool rgbOk = false, deltaOk;
6374                   if ( i+1 >= colors.count() ) break;                  // format error
6375                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6376                   int delta = colors[i+1].toInt( &deltaOk );
6377                   i++;                                 // shift index
6378                   if ( i+1 < colors.count() )          // index is shifted to 1
6379                     g = colors[i+1].toDouble( &rgbOk );
6380                   if ( rgbOk ) i++;                    // shift index
6381                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6382                     b = colors[i+1].toDouble( &rgbOk );
6383                   if ( rgbOk ) i++;
6384                   // - as currently there's no way to set directly backsurface color as it was before,
6385                   // we ignore old dump where r,g,b triple was set
6386                   // - also we check that delta parameter is set properly
6387                   if ( !rgbOk && deltaOk )
6388                     deltaF = delta;
6389                 }
6390                 else if ( type == "volume" ) {
6391                   // volume color is set by 4 values r:g:b:delta, where
6392                   // - r,g,b - is a normal volume rgb color components
6393                   // - delta - is a reversed volume color delta coefficient
6394                   if ( i+1 >= colors.count() ) break;                  // format error
6395                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6396                   if ( i+2 >= colors.count() ) break;                  // format error
6397                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6398                   if ( i+3 >= colors.count() ) break;                  // format error
6399                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6400                   if ( i+4 >= colors.count() ) break;                  // format error
6401                   int delta = colors[i+4].toInt( &bOk );
6402                   if ( !bOk ) break;                                   // format error
6403                   volumeColor.setRgbF( r, g, b );
6404                   deltaV = delta;
6405                   i += 4;
6406                 }
6407                 else if ( type == "edge" ) {
6408                   // edge color is set by 3 values r:g:b, where
6409                   // - r,g,b - is rgb color components
6410                   if ( i+1 >= colors.count() ) break;                  // format error
6411                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6412                   if ( i+2 >= colors.count() ) break;                  // format error
6413                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6414                   if ( i+3 >= colors.count() ) break;                  // format error
6415                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6416                   edgeColor.setRgbF( r, g, b );
6417                   i += 3;
6418                 }
6419                 else if ( type == "node" ) {
6420                   // node color is set by 3 values r:g:b, where
6421                   // - r,g,b - is rgb color components
6422                   if ( i+1 >= colors.count() ) break;                  // format error
6423                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6424                   if ( i+2 >= colors.count() ) break;                  // format error
6425                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6426                   if ( i+3 >= colors.count() ) break;                  // format error
6427                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6428                   nodeColor.setRgbF( r, g, b );
6429                   i += 3;
6430                 }
6431                 else if ( type == "elem0d" ) {
6432                   // 0d element color is set by 3 values r:g:b, where
6433                   // - r,g,b - is rgb color components
6434                   if ( i+1 >= colors.count() ) break;                  // format error
6435                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6436                   if ( i+2 >= colors.count() ) break;                  // format error
6437                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6438                   if ( i+3 >= colors.count() ) break;                  // format error
6439                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6440                   elem0dColor.setRgbF( r, g, b );
6441                   i += 3;
6442                 }
6443                 else if ( type == "ball" ) {
6444                   // ball color is set by 3 values r:g:b, where
6445                   // - r,g,b - is rgb color components
6446                   if ( i+1 >= colors.count() ) break;                  // format error
6447                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6448                   if ( i+2 >= colors.count() ) break;                  // format error
6449                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6450                   if ( i+3 >= colors.count() ) break;                  // format error
6451                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6452                   ballColor.setRgbF( r, g, b );
6453                   i += 3;
6454                 }
6455                 else if ( type == "outline" ) {
6456                   // outline color is set by 3 values r:g:b, where
6457                   // - r,g,b - is rgb color components
6458                   if ( i+1 >= colors.count() ) break;                  // format error
6459                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6460                   if ( i+2 >= colors.count() ) break;                  // format error
6461                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6462                   if ( i+3 >= colors.count() ) break;                  // format error
6463                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6464                   outlineColor.setRgbF( r, g, b );
6465                   i += 3;
6466                 }
6467                 else if ( type == "orientation" ) {
6468                   // orientation color is set by 3 values r:g:b, where
6469                   // - r,g,b - is rgb color components
6470                   if ( i+1 >= colors.count() ) break;                  // format error
6471                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6472                   if ( i+2 >= colors.count() ) break;                  // format error
6473                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6474                   if ( i+3 >= colors.count() ) break;                  // format error
6475                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6476                   orientationColor.setRgbF( r, g, b );
6477                   i += 3;
6478                 }
6479               }
6480               // node color
6481               if ( nodeColor.isValid() )
6482                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6483               // edge color
6484               if ( edgeColor.isValid() )
6485                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6486               // face color
6487               if ( faceColor.isValid() )
6488                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6489               // volume color
6490               if ( volumeColor.isValid() )
6491                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6492               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6493                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6494               // 0d element color
6495               if ( elem0dColor.isValid() )
6496                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6497               // ball color
6498               if ( ballColor.isValid() )
6499                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6500               // outline color
6501               if ( outlineColor.isValid() )
6502                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6503               // orientation color
6504               if ( orientationColor.isValid() )
6505                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6506             }
6507             // Sizes
6508             else if (paramNameStr == "Sizes") {
6509               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6510               bool bOk;
6511               int lineWidth = -1;
6512               int outlineWidth = -1;
6513               int elem0dSize = -1;
6514               //int ballSize = -1;
6515               double ballDiameter = -1.0;
6516               double ballScale = -1.0;
6517               double shrinkSize = -1;
6518               double orientationSize = -1;
6519               bool orientation3d = false;
6520               for ( int i = 0; i < sizes.count(); i++ ) {
6521                 QString type = sizes[i];
6522                 if ( type == "line" ) {
6523                   // line (wireframe) width is given as single integer value
6524                   if ( i+1 >= sizes.count() ) break;                    // format error
6525                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6526                   lineWidth = v;
6527                   i++;
6528                 }
6529                 if ( type == "outline" ) {
6530                   // outline width is given as single integer value
6531                   if ( i+1 >= sizes.count() ) break;                    // format error
6532                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6533                   outlineWidth = v;
6534                   i++;
6535                 }
6536                 else if ( type == "elem0d" ) {
6537                   // 0d element size is given as single integer value
6538                   if ( i+1 >= sizes.count() ) break;                    // format error
6539                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6540                   elem0dSize = v;
6541                   i++;
6542                 }
6543                 else if ( type == "ball" ) {
6544                   // balls are specified by two values: size:scale, where
6545                   // - size - is a integer value specifying size
6546                   // - scale - is a double value specifying scale factor
6547                   if ( i+1 >= sizes.count() ) break;                       // format error
6548                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6549                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6550                   if ( i+2 >= sizes.count() ) break;                       // format error
6551                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6552                   //ballSize = v1;
6553                   ballDiameter = v1;
6554                   ballScale = v2;
6555                   i += 2;
6556                 }
6557                 else if ( type == "shrink" ) {
6558                   // shrink factor is given as single floating point value
6559                   if ( i+1 >= sizes.count() ) break;                          // format error
6560                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6561                   shrinkSize = v;
6562                   i++;
6563                 }
6564                 else if ( type == "orientation" ) {
6565                   // orientation vectors are specified by two values size:3d, where
6566                   // - size - is a floating point value specifying scale factor
6567                   // - 3d - is a boolean
6568                   if ( i+1 >= sizes.count() ) break;                          // format error
6569                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6570                   if ( i+2 >= sizes.count() ) break;                          // format error
6571                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6572                   orientationSize = v1;
6573                   orientation3d = (bool)v2;
6574                   i += 2;
6575                 }
6576               }
6577               // line (wireframe) width
6578               if ( lineWidth > 0 )
6579                 aSmeshActor->SetLineWidth( lineWidth );
6580               // outline width
6581               if ( outlineWidth > 0 )
6582                 aSmeshActor->SetOutlineWidth( outlineWidth );
6583               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6584                 aSmeshActor->SetOutlineWidth( lineWidth );
6585               // 0d element size
6586               if ( elem0dSize > 0 )
6587                 aSmeshActor->Set0DSize( elem0dSize );
6588               // ball size
6589               /*if ( ballSize > 0 )
6590                 aSmeshActor->SetBallSize( ballSize );*/
6591               // ball diameter
6592               if ( ballDiameter > 0 )
6593                 aSmeshActor->SetBallSize( ballDiameter );
6594               // ball scale
6595               if ( ballScale > 0.0 )
6596                 aSmeshActor->SetBallScale( ballScale );
6597               // shrink factor
6598               if ( shrinkSize > 0 )
6599                 aSmeshActor->SetShrinkFactor( shrinkSize );
6600               // orientation vectors
6601               if ( orientationSize > 0 ) {
6602                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6603                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6604               }
6605             }
6606             // Point marker
6607             else if (paramNameStr == "PointMarker") {
6608               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6609               if( data.count() >= 2 ) {
6610                 bool ok = false;
6611                 int aParam1 = data[1].toInt( &ok );
6612                 if( ok ) {
6613                   if( data[0] == "std" && data.count() == 3 ) {
6614                     int aParam2 = data[2].toInt( &ok );
6615                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6616                   }
6617                   else if( data[0] == "custom" ) {
6618                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6619                     if( markerIt != aMarkerMap.end() ) {
6620                       VTK::MarkerData aMarkerData = markerIt->second;
6621                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6622                     }
6623                   }
6624                 }
6625               }
6626             }
6627             // Opacity
6628             else if (paramNameStr == "Opacity") {
6629               aSmeshActor->SetOpacity(val.toFloat());
6630             }
6631             // Clipping
6632             else if (paramNameStr.startsWith("ClippingPlane")) {
6633               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6634               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6635               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6636               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6637               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6638               // new format - val looks like "Off" or "0" (plane id)
6639               // (note: in new format "Off" value is used only for consistency,
6640               //  so it is processed together with values in old format)
6641               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6642               if( anIsOldFormat ) {
6643                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6644                   aSmeshActor->RemoveAllClippingPlanes();
6645                 if (val != "Off") {
6646                   QList<SUIT_ViewManager*> lst;
6647                   getApp()->viewManagers(viewerTypStr, lst);
6648                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6649                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6650                     SUIT_ViewManager* vman = lst.at(viewIndex);
6651                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6652
6653                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6654
6655                     SMESH::TActorList anActorList;
6656                     anActorList.push_back( aSmeshActor );
6657                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6658                     aPlane->myViewWindow = vtkView;
6659                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6660                     aPlane->PlaneMode = aMode;
6661                     bool isOpenGLClipping = ( bool )vals[1].toInt();
6662                     aPlane->IsOpenGLClipping = isOpenGLClipping;
6663                     if ( aMode == SMESH::Absolute ) {
6664                       aPlane->myAbsoluteOrientation = vals[2].toInt();
6665                       aPlane->X = vals[3].toFloat();
6666                       aPlane->Y = vals[4].toFloat();
6667                       aPlane->Z = vals[5].toFloat();
6668                       aPlane->Dx = vals[6].toFloat();
6669                       aPlane->Dy = vals[7].toFloat();
6670                       aPlane->Dz = vals[8].toFloat();
6671                     }
6672                     else if ( aMode == SMESH::Relative ) {
6673                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6674                       aPlane->myDistance = vals[3].toFloat();
6675                       aPlane->myAngle[0] = vals[4].toFloat();
6676                       aPlane->myAngle[1] = vals[5].toFloat();
6677                     }
6678
6679                     if( aPlane ) {
6680                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6681                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6682                         aClippingPlaneInfo.Plane = aPlane;
6683                         aClippingPlaneInfo.ActorList = anActorList;
6684                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6685                       }
6686                     }
6687                   }
6688                 }
6689               }
6690               else {
6691                 bool ok = false;
6692                 int aPlaneId = val.toInt( &ok );
6693                 if( ok && aPlaneId >= 0 ) {
6694                   bool anIsDefinedPlane = false;
6695                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6696                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6697                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6698                     TPlaneInfo& aPlaneInfo = *anIter;
6699                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6700                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6701                       anIsDefinedPlane = true;
6702                       break;
6703                     }
6704                   }
6705                   if( !anIsDefinedPlane ) {
6706                     TPlaneInfo aPlaneInfo;
6707                     aPlaneInfo.PlaneId = aPlaneId;
6708                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6709                     aPlaneInfo.ViewManager = vman;
6710
6711                     // to make the list sorted by plane id
6712                     anIter = aPlaneInfoList.begin();
6713                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6714                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6715                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6716                         break;
6717                     }
6718                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6719                   }
6720                 }
6721               }
6722             }
6723           } // if (aSmeshActor)
6724         } // other parameters than Visibility
6725       }
6726     } // for names/parameters iterator
6727   } // for entries iterator
6728
6729   // take into account planes with empty list of actors referred to them
6730   QList<SUIT_ViewManager*> aVMList;
6731   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6732
6733   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6734   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6735     int aViewId = aPlaneDataIter->first;
6736     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6737       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6738
6739       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6740
6741       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6742       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6743       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6744         const TPlaneData& aPlaneData = *anIter2;
6745         int aPlaneId = aPlaneData.Id;
6746
6747         bool anIsFound = false;
6748         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6749         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6750           const TPlaneInfo& aPlaneInfo = *anIter3;
6751           if( aPlaneInfo.PlaneId == aPlaneId ) {
6752             anIsFound = true;
6753             break;
6754           }
6755         }
6756
6757         if( !anIsFound ) {
6758           TPlaneInfo aPlaneInfo; // ActorList field is empty
6759           aPlaneInfo.PlaneId = aPlaneId;
6760           aPlaneInfo.ViewManager = aViewManager;
6761
6762           // to make the list sorted by plane id
6763           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6764           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6765             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6766             if( aPlaneInfoRef.PlaneId > aPlaneId )
6767               break;
6768           }
6769           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6770         }
6771       }
6772     }
6773   }
6774
6775   // add clipping planes to actors according to the restored parameters
6776   // and update the clipping plane map
6777   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6778   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6779     int aViewId = anIter1->first;
6780     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6781
6782     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6783     if( anIter2 == aPlaneDataMap.end() )
6784       continue;
6785     const TPlaneDataList& aPlaneDataList = anIter2->second;
6786
6787     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6788     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6789       const TPlaneInfo& aPlaneInfo = *anIter3;
6790       int aPlaneId = aPlaneInfo.PlaneId;
6791       const TActorList& anActorList = aPlaneInfo.ActorList;
6792       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6793       if( !aViewManager )
6794         continue;
6795
6796       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6797       if( !aViewWindow )
6798         continue;
6799
6800       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6801
6802       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6803       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6804         const TPlaneData& aPlaneData = *anIter4;
6805         if( aPlaneData.Id == aPlaneId ) {
6806           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6807           aPlane->myViewWindow = aViewWindow;
6808           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6809           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6810           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6811             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6812             aPlane->X = aPlaneData.X;
6813             aPlane->Y = aPlaneData.Y;
6814             aPlane->Z = aPlaneData.Z;
6815             aPlane->Dx = aPlaneData.Dx;
6816             aPlane->Dy = aPlaneData.Dy;
6817             aPlane->Dz = aPlaneData.Dz;
6818           }
6819           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6820             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6821             aPlane->myDistance = aPlaneData.Distance;
6822             aPlane->myAngle[0] = aPlaneData.Angle[0];
6823             aPlane->myAngle[1] = aPlaneData.Angle[1];
6824           }
6825           if( aPlane ) {
6826             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6827               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6828               aClippingPlaneInfo.Plane = aPlane;
6829               aClippingPlaneInfo.ActorList = anActorList;
6830               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6831             }
6832           }
6833           break;
6834         }
6835       }
6836
6837     }
6838   }
6839
6840
6841   // update all VTK views
6842   QList<SUIT_ViewManager*> lst;
6843   getApp()->viewManagers(lst);
6844   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6845     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6846     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6847       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6848       // set OpenGL clipping planes
6849       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6850       vtkActorCollection* anAllActors = aCopy.GetActors();
6851       anAllActors->InitTraversal();
6852       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6853         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6854           anActor->SetOpenGLClippingPlane();
6855
6856       vtkView->getRenderer()->ResetCameraClippingRange();
6857       vtkView->Repaint();
6858     }
6859   }
6860 }
6861
6862 /*!
6863   \brief Adds preferences for dfont of VTK viewer
6864   \param label label
6865   \param pIf group identifier
6866   \param param parameter
6867   \return identifier of preferences
6868 */
6869 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6870 {
6871   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6872
6873   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6874
6875   QStringList fam;
6876   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6877   fam.append( tr( "SMESH_FONT_COURIER" ) );
6878   fam.append( tr( "SMESH_FONT_TIMES" ) );
6879
6880   setPreferenceProperty( tfont, "fonts", fam );
6881
6882   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6883   if ( needSize ) f = f | QtxFontEdit::Size;
6884   setPreferenceProperty( tfont, "features", f );
6885
6886   return tfont;
6887 }
6888
6889 /*!
6890   \brief Actions after hypothesis edition
6891   Updates object browser after hypothesis edition
6892 */
6893 void SMESHGUI::onHypothesisEdit( int result )
6894 {
6895   if( result == 1 )
6896     SMESHGUI::Modified();
6897   updateObjBrowser( true );
6898 }
6899
6900 /*!
6901   \brief Actions after choosing menu of control modes
6902   Updates control mode actions according to current selection
6903 */
6904 void SMESHGUI::onUpdateControlActions()
6905 {
6906   SALOME_ListIO selected;
6907   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6908     aSel->selectedObjects( selected );
6909
6910   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6911   if ( selected.Extent() ) {
6912     if ( selected.First()->hasEntry() ) {
6913       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6914         aControl = anActor->GetControlMode();
6915         SALOME_ListIteratorOfListIO it(selected);
6916         for ( it.Next(); it.More(); it.Next() ) {
6917           Handle(SALOME_InteractiveObject) anIO = it.Value();
6918           if ( anIO->hasEntry() ) {
6919             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6920               if ( aControl != anActor->GetControlMode() ) {
6921                 aControl = SMESH_Actor::eNone;
6922                 break;
6923               }
6924             }
6925           }
6926         }
6927       }
6928     }
6929   }
6930
6931   int anAction = ActionToControl( aControl, true );
6932   if ( anAction)
6933     action( anAction )->setChecked( true );
6934   else {
6935     QMenu* send = (QMenu*)sender();
6936     QList<QAction*> actions = send->actions();
6937     for ( int i = 0; i < actions.size(); i++ )
6938       actions[i]->setChecked( false );
6939   }
6940 }
6941
6942
6943 /*!
6944   \brief Signal handler closing(SUIT_ViewWindow*) of a view
6945   \param pview view being closed
6946 */
6947 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6948 #ifndef DISABLE_PLOT2DVIEWER
6949   //Crear all Plot2d Viewers if need.
6950   SMESH::ClearPlot2Viewers(pview);
6951 #endif
6952   EmitSignalCloseView();
6953 }
6954
6955 void SMESHGUI::message( const QString& msg )
6956 {
6957   // dispatch message
6958   QStringList data = msg.split("/");
6959   if ( data.count() > 0 ) {
6960     if ( data.first() == "mesh_loading" ) {
6961       // get mesh entry
6962       QString entry = data.count() > 1 ? data[1] : QString();
6963       if ( entry.isEmpty() )
6964         return;
6965       // get study
6966       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6967       // get mesh name
6968       _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6969       QString name;
6970       if ( obj )
6971         name = SMESH::fromUtf8(obj->GetName());
6972       if ( name.isEmpty() )
6973         return;
6974
6975       if ( data.last() == "stop" )
6976         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6977       else
6978         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6979       QApplication::processEvents();
6980     }
6981   }
6982 }
6983
6984 /*!
6985   \brief Connects or disconnects signals about activating and cloning view on the module slots
6986   \param pview view which is connected/disconnected
6987 */
6988 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6989   if(!pview)
6990     return;
6991
6992   SUIT_ViewManager* viewMgr = pview->getViewManager();
6993   if ( viewMgr ) {
6994     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6995                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6996
6997     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6998              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6999   }
7000 }
7001
7002 /*!
7003   \brief Return \c true if object can be renamed
7004 */
7005 bool SMESHGUI::renameAllowed( const QString& entry) const {
7006   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7007   if( !anApp )
7008     return false;
7009
7010   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7011   if( !appStudy )
7012     return false;
7013
7014   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7015
7016   if(!obj)
7017     return false;
7018
7019   if(appStudy->isComponent(entry) || obj->isReference())
7020     return false;
7021
7022   // check type to prevent renaming of inappropriate objects
7023   int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7024   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7025       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7026       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7027       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7028       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7029     return true;
7030
7031   return false;
7032 }
7033
7034 /*!
7035   Rename object by entry.
7036   \param entry entry of the object
7037   \param name new name of the object
7038   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7039 */
7040 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7041
7042   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7043   if( !anApp )
7044     return false;
7045
7046   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7047
7048   if(!appStudy)
7049     return false;
7050
7051   _PTR(Study) aStudy = appStudy->studyDS();
7052
7053   if(!aStudy)
7054     return false;
7055
7056   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7057   if ( aLocked ) {
7058     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7059     return false;
7060   }
7061
7062
7063   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7064   _PTR(GenericAttribute) anAttr;
7065   _PTR(AttributeName) aName;
7066   if ( obj ) {
7067     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7068       aName = anAttr;
7069       // check type to prevent renaming of inappropriate objects
7070       int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7071       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7072           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7073           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7074           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7075           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7076         if ( !name.isEmpty() ) {
7077           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7078
7079           // update name of group object and its actor
7080           Handle(SALOME_InteractiveObject) IObject =
7081             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7082
7083           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7084           if( !aGroupObject->_is_nil() ) {
7085             aGroupObject->SetName( qPrintable(name) );
7086             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7087               anActor->setName( qPrintable(name) );
7088           }
7089           return true;
7090         }
7091       }
7092     }
7093   }
7094   return false;
7095 }
7096
7097 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7098 {
7099   static QList<QColor> colors;
7100
7101   if ( colors.isEmpty() ) {
7102
7103     for (int s = 0; s < 2 ; s++)
7104     {
7105       for (int v = 100; v >= 40; v = v - 20)
7106       {
7107         for (int h = 0; h < 359 ; h = h + 60)
7108         {
7109           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7110         }
7111       }
7112     }
7113   }
7114   static int currentColor = randomize( colors.size() );
7115
7116   SALOMEDS::Color color;
7117   color.R = (double)colors[currentColor].red()   / 255.0;
7118   color.G = (double)colors[currentColor].green() / 255.0;
7119   color.B = (double)colors[currentColor].blue()  / 255.0;
7120
7121   currentColor = (currentColor+1) % colors.count();
7122
7123   return color;
7124 }