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