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