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           }
2544         }
2545       }
2546       SMESH::UpdateView();
2547       break;
2548     }
2549   case SMESHOp::OpScalarBarProperties:
2550     {
2551       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2552       break;
2553     }
2554   case SMESHOp::OpShowScalarBar:
2555     {
2556       // show/hide scalar bar
2557       ::ShowElement(theCommandID);
2558       break;
2559     }
2560   case SMESHOp::OpSaveDistribution:
2561     {
2562       // dump control distribution data to the text file
2563       ::SaveDistribution();
2564       break;
2565     }
2566
2567   case SMESHOp::OpShowDistribution:
2568     {
2569       // show/hide distribution
2570       ::ShowElement(theCommandID);
2571       break;
2572     }
2573
2574 #ifndef DISABLE_PLOT2DVIEWER
2575   case SMESHOp::OpPlotDistribution:
2576     {
2577       // plot distribution
2578       ::PlotDistribution();
2579       break;
2580     }
2581 #endif
2582
2583     // Auto-color
2584   case SMESHOp::OpAutoColor:
2585     ::AutoColor();
2586   break;
2587
2588   case SMESHOp::OpDisableAutoColor:
2589     ::DisableAutoColor();
2590   break;
2591
2592   case SMESHOp::OpClipping:
2593   case SMESHOp::OpTransparency:
2594   case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2595
2596     // Display Mode
2597   case SMESHOp::OpDMWireframe:
2598   case SMESHOp::OpDMShading:
2599   case SMESHOp::OpDMNodes:
2600   case SMESHOp::OpDMShrink:
2601     ::SetDisplayMode(theCommandID, myMarkerMap);
2602   break;
2603
2604   //2D quadratic representation
2605   case SMESHOp::OpRepresentationLines:
2606   case SMESHOp::OpRepresentationArcs:
2607     ::SetDisplayMode(theCommandID, myMarkerMap);
2608   break;
2609
2610   // Display Entity
2611   case SMESHOp::OpDE0DElements:
2612   case SMESHOp::OpDEEdges:
2613   case SMESHOp::OpDEFaces:
2614   case SMESHOp::OpDEVolumes:
2615   case SMESHOp::OpDEBalls:
2616   case SMESHOp::OpDEAllEntity:
2617     ::SetDisplayEntity(theCommandID);
2618   break;
2619
2620   // Choose entities to be displayed
2621   case SMESHOp::OpDEChoose:
2622     {
2623       ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2624       break;
2625     }
2626
2627   case SMESHOp::OpOrientationOnFaces:
2628     {
2629       SUIT_OverrideCursor wc;
2630       LightApp_SelectionMgr* mgr = selectionMgr();
2631       SALOME_ListIO selected; mgr->selectedObjects( selected );
2632
2633       SALOME_ListIteratorOfListIO it(selected);
2634       for( ; it.More(); it.Next()) {
2635         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2636         if(anIObject->hasEntry()) {
2637           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2638             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2639           }
2640         }
2641       }
2642       break;
2643     }
2644
2645   case SMESHOp::OpUpdate:
2646     {
2647       if(isStudyLocked()) break;
2648       SUIT_OverrideCursor wc;
2649       try {
2650         OCC_CATCH_SIGNALS;
2651         SMESH::UpdateView();
2652       }
2653       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2654         SMESH::OnVisuException();
2655       }
2656       catch (...) { // PAL16774 (Crash after display of many groups)
2657         SMESH::OnVisuException();
2658       }
2659
2660       SALOME_ListIO l;
2661       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2662       aSel->selectedObjects( l );
2663       aSel->setSelectedObjects( l );
2664       break;
2665     }
2666
2667   case SMESHOp::OpHide:
2668   case SMESHOp::OpShow:
2669   case SMESHOp::OpShowOnly:
2670     {
2671       SUIT_OverrideCursor wc;
2672       SMESH::EDisplaing anAction;
2673       switch (theCommandID) {
2674       case SMESHOp::OpHide:     anAction = SMESH::eErase; break;
2675       case SMESHOp::OpShow:     anAction = SMESH::eDisplay; break;
2676       case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2677       }
2678
2679       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2680       SALOME_ListIO sel_objects, to_process;
2681       if (aSel)
2682         aSel->selectedObjects( sel_objects );
2683
2684       if ( theCommandID==SMESHOp::OpShowOnly )
2685       {
2686         //MESSAGE("anAction = SMESH::eDisplayOnly");
2687         startOperation( myEraseAll );
2688       }
2689
2690       extractContainers( sel_objects, to_process );
2691
2692       try {
2693         OCC_CATCH_SIGNALS;
2694         if (vtkwnd) {
2695           SALOME_ListIteratorOfListIO It( to_process );
2696           for ( ; It.More(); It.Next())
2697           {
2698             Handle(SALOME_InteractiveObject) IOS = It.Value();
2699             if ( IOS->hasEntry() )
2700             {
2701               if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2702                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2703                 break; // PAL16774 (Crash after display of many groups)
2704               }
2705               if (anAction == SMESH::eDisplayOnly)
2706                 anAction = SMESH::eDisplay;
2707             }
2708           }
2709         }
2710
2711         // PAL13338 + PAL15161 -->
2712         if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2713           SMESH::UpdateView();
2714           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2715         }
2716         // PAL13338 + PAL15161 <--
2717       }
2718       catch (...) { // PAL16774 (Crash after display of many groups)
2719         SMESH::OnVisuException();
2720       }
2721
2722       if (anAction == SMESH::eErase) {
2723         SALOME_ListIO l1;
2724         aSel->setSelectedObjects( l1 );
2725       }
2726       else
2727         aSel->setSelectedObjects( to_process );
2728
2729       break;
2730     }
2731
2732   case SMESHOp::OpNode:
2733     {
2734       if(isStudyLocked()) break;
2735
2736       if ( vtkwnd ) {
2737         EmitSignalDeactivateDialog();
2738
2739         ( new SMESHGUI_NodesDlg( this ) )->show();
2740       }
2741       else {
2742         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2743       }
2744       break;
2745     }
2746
2747   case SMESHOp::OpCreateMesh:
2748   case SMESHOp::OpCreateSubMesh:
2749   case SMESHOp::OpEditMeshOrSubMesh:
2750   case SMESHOp::OpEditMesh:
2751   case SMESHOp::OpEditSubMesh:
2752   case SMESHOp::OpCompute:
2753   case SMESHOp::OpComputeSubMesh:
2754   case SMESHOp::OpPreCompute:
2755   case SMESHOp::OpEvaluate:
2756   case SMESHOp::OpMeshOrder:
2757     startOperation( theCommandID );
2758     break;
2759   case SMESHOp::OpCopyMesh:
2760     {
2761       if (isStudyLocked()) break;
2762       EmitSignalDeactivateDialog();
2763       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2764     }
2765     break;
2766   case SMESHOp::OpBuildCompoundMesh:
2767     {
2768       if (isStudyLocked()) break;
2769       EmitSignalDeactivateDialog();
2770       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2771     }
2772     break;
2773
2774   case SMESHOp::OpDiagonalInversion:
2775   case SMESHOp::OpUnionOfTwoTriangle:
2776     {
2777       if ( !vtkwnd )
2778       {
2779         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2780         break;
2781       }
2782
2783       if ( isStudyLocked() )
2784         break;
2785
2786       /*Standard_Boolean aRes;
2787       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2788       if ( aMesh->_is_nil() )
2789       {
2790         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2791           tr( "SMESH_BAD_SELECTION" ) );
2792         break;
2793       }
2794       */
2795       EmitSignalDeactivateDialog();
2796       if ( theCommandID == SMESHOp::OpDiagonalInversion )
2797         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2798       else
2799         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2800       break;
2801     }
2802   case SMESHOp::OpOrientation:
2803   case SMESHOp::OpUnionOfTriangles:
2804   case SMESHOp::OpCuttingOfQuadrangles:
2805   case SMESHOp::OpSplitVolumes:
2806     {
2807       if ( !vtkwnd )
2808       {
2809         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2810         break;
2811       }
2812
2813       if ( isStudyLocked() )
2814         break;
2815
2816       EmitSignalDeactivateDialog();
2817       SMESHGUI_MultiEditDlg* aDlg = NULL;
2818       if ( theCommandID == SMESHOp::OpOrientation )
2819         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2820       else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2821         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2822       else if ( theCommandID == SMESHOp::OpSplitVolumes )
2823         aDlg = new SMESHGUI_SplitVolumesDlg(this);
2824       else
2825         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2826
2827       aDlg->show();
2828       break;
2829     }
2830   case SMESHOp::OpSmoothing:
2831     {
2832       if(isStudyLocked()) break;
2833       if( vtkwnd ) {
2834         EmitSignalDeactivateDialog();
2835         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2836       }
2837       else {
2838         SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2839       }
2840       break;
2841     }
2842   case SMESHOp::OpExtrusion:
2843     {
2844       if (isStudyLocked()) break;
2845       if (vtkwnd) {
2846         EmitSignalDeactivateDialog();
2847         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2848       } else {
2849         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2850       }
2851       break;
2852     }
2853   case SMESHOp::OpExtrusionAlongAPath:
2854     {
2855       if (isStudyLocked()) break;
2856       if (vtkwnd) {
2857         EmitSignalDeactivateDialog();
2858         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2859       } else {
2860         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2861       }
2862       break;
2863     }
2864   case SMESHOp::OpRevolution:
2865     {
2866       if(isStudyLocked()) break;
2867       if( vtkwnd ) {
2868         EmitSignalDeactivateDialog();
2869         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2870       }
2871       else {
2872         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2873       }
2874       break;
2875     }
2876   case SMESHOp::OpPatternMapping:
2877     {
2878       if ( isStudyLocked() )
2879         break;
2880       if ( vtkwnd )
2881       {
2882         EmitSignalDeactivateDialog();
2883         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2884       }
2885       else {
2886         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2887       }
2888       break;
2889     }
2890   case SMESHOp::OpSplitBiQuadratic:
2891   case SMESHOp::OpConvertMeshToQuadratic:
2892   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2893   case SMESHOp::OpReorientFaces:
2894   case SMESHOp::OpCreateGeometryGroup:
2895     {
2896       startOperation( theCommandID );
2897       break;
2898     }
2899   case SMESHOp::OpCreateGroup:
2900     {
2901       if ( !vtkwnd )
2902       {
2903         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2904         break;
2905       }
2906
2907       if(isStudyLocked()) break;
2908       EmitSignalDeactivateDialog();
2909       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2910
2911       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2912       SALOME_ListIO selected;
2913       if( aSel )
2914         aSel->selectedObjects( selected );
2915
2916       int nbSel = selected.Extent();
2917       if (nbSel == 1) {
2918         // check if mesh is selected
2919         aMesh = SMESH::GetMeshByIO( selected.First() );
2920       }
2921       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2922       aDlg->show();
2923       break;
2924     }
2925
2926   case SMESHOp::OpConstructGroup:
2927     {
2928       if ( !vtkwnd )
2929       {
2930         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2931         break;
2932       }
2933
2934       if(isStudyLocked()) break;
2935       EmitSignalDeactivateDialog();
2936
2937       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2938       SALOME_ListIO selected;
2939       if( aSel )
2940         aSel->selectedObjects( selected );
2941
2942       int nbSel = selected.Extent();
2943       if (nbSel == 1) {
2944         // check if submesh is selected
2945         Handle(SALOME_InteractiveObject) IObject = selected.First();
2946         if (IObject->hasEntry()) {
2947           _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2948           if( aSObj ) {
2949             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2950             if (!aSubMesh->_is_nil()) {
2951               try {
2952                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2953                 // get submesh elements list by types
2954                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2955                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2956                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2957                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2958                 // create group for each type o elements
2959                 QString aName = IObject->getName();
2960                 QStringList anEntryList;
2961                 if (aNodes->length() > 0) {
2962                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2963                   aGroup->Add(aNodes.inout());
2964                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2965                     anEntryList.append( aSObject->GetID().c_str() );
2966                 }
2967                 if (aEdges->length() > 0) {
2968                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2969                   aGroup->Add(aEdges.inout());
2970                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2971                     anEntryList.append( aSObject->GetID().c_str() );
2972                 }
2973                 if (aFaces->length() > 0) {
2974                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2975                   aGroup->Add(aFaces.inout());
2976                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2977                     anEntryList.append( aSObject->GetID().c_str() );
2978                 }
2979                 if (aVolumes->length() > 0) {
2980                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2981                   aGroup->Add(aVolumes.inout());
2982                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2983                     anEntryList.append( aSObject->GetID().c_str() );
2984                 }
2985                 updateObjBrowser();
2986                 anApp->browseObjects( anEntryList );
2987               }
2988               catch(const SALOME::SALOME_Exception & S_ex){
2989                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2990               }
2991             }
2992           }
2993         }
2994       }
2995       else if(nbSel==0) {
2996         SUIT_MessageBox::warning(desktop(),
2997                                  tr("SMESH_WRN_WARNING"),
2998                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2999       }
3000       break;
3001     }
3002
3003   case SMESHOp::OpEditGroup:
3004     {
3005       if ( !vtkwnd )
3006       {
3007         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3008         break;
3009       }
3010
3011       if(isStudyLocked()) break;
3012       EmitSignalDeactivateDialog();
3013
3014       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3015       SALOME_ListIO selected;
3016       if( aSel )
3017         aSel->selectedObjects( selected );
3018
3019       SALOME_ListIteratorOfListIO It (selected);
3020       int nbSelectedGroups = 0;
3021       for ( ; It.More(); It.Next() )
3022       {
3023         SMESH::SMESH_GroupBase_var aGroup =
3024           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3025         if (!aGroup->_is_nil()) {
3026           nbSelectedGroups++;
3027           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3028           aDlg->show();
3029         }
3030       }
3031       if (nbSelectedGroups == 0)
3032         {
3033           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3034           aDlg->show();
3035         }
3036       break;
3037     }
3038
3039   case SMESHOp::OpAddElemGroupPopup:     // Add elements to group
3040     {
3041       if(isStudyLocked()) break;
3042       if (myState == 800) {
3043         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3044         if (aDlg) aDlg->onAdd();
3045       }
3046       break;
3047     }
3048
3049   case SMESHOp::OpRemoveElemGroupPopup:  // Remove elements from group
3050     {
3051       if(isStudyLocked()) break;
3052       if (myState == 800) {
3053         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3054         if (aDlg) aDlg->onRemove();
3055       }
3056       break;
3057     }
3058
3059   case SMESHOp::OpEditGeomGroupAsGroup:
3060     {
3061       if ( !vtkwnd )
3062       {
3063         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3064         break;
3065       }
3066
3067       if(isStudyLocked()) break;
3068       EmitSignalDeactivateDialog();
3069
3070       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3071       SALOME_ListIO selected;
3072       if( aSel )
3073         aSel->selectedObjects( selected );
3074
3075       SALOME_ListIteratorOfListIO It (selected);
3076       for ( ; It.More(); It.Next() )
3077       {
3078         SMESH::SMESH_GroupOnGeom_var aGroup =
3079           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3080         if (!aGroup->_is_nil()) {
3081           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3082           aDlg->show();
3083         }
3084         else
3085         {
3086           SMESH::SMESH_GroupOnFilter_var aGroup =
3087             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3088           if (!aGroup->_is_nil()) {
3089             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3090             aDlg->show();
3091           }
3092         }
3093       }
3094       break;
3095     }
3096
3097     case SMESHOp::OpUnionGroups:
3098     case SMESHOp::OpIntersectGroups:
3099     case SMESHOp::OpCutGroups:
3100     {
3101       if ( !vtkwnd )
3102       {
3103         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3104         break;
3105       }
3106
3107       if ( isStudyLocked() )
3108         break;
3109
3110       EmitSignalDeactivateDialog();
3111
3112       SMESHGUI_GroupOpDlg* aDlg = 0;
3113       if ( theCommandID == SMESHOp::OpUnionGroups )
3114         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3115       else if ( theCommandID == SMESHOp::OpIntersectGroups )
3116         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3117       else
3118         aDlg = new SMESHGUI_CutGroupsDlg( this );
3119
3120       aDlg->show();
3121
3122       break;
3123     }
3124
3125     case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3126     {
3127       if ( isStudyLocked() )
3128         break;
3129
3130       EmitSignalDeactivateDialog();
3131       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3132       aDlg->show();
3133
3134       break;
3135     }
3136
3137     case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3138     {
3139       if ( isStudyLocked() )
3140         break;
3141
3142       EmitSignalDeactivateDialog();
3143       SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3144       aDlg->show();
3145
3146       break;
3147     }
3148
3149     case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3150     {
3151       if ( !vtkwnd )
3152       {
3153         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3154         break;
3155       }
3156
3157       if ( isStudyLocked() )
3158         break;
3159
3160       EmitSignalDeactivateDialog();
3161
3162       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3163       break;
3164     }
3165
3166   case SMESHOp::OpMeshInformation:
3167   case SMESHOp::OpWhatIs:
3168     {
3169       int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3170       EmitSignalDeactivateDialog();
3171       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3172       SALOME_ListIO selected;
3173       if( aSel )
3174         aSel->selectedObjects( selected );
3175
3176       if ( selected.Extent() > 1 ) { // a dlg for each IO
3177         SALOME_ListIteratorOfListIO It( selected );
3178         for ( ; It.More(); It.Next() ) {
3179           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3180           dlg->showInfo( It.Value() );
3181           dlg->show();
3182         }
3183       }
3184       else {
3185         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3186         dlg->show();
3187       }
3188       break;
3189     }
3190
3191   case SMESHOp::OpFindElementByPoint:
3192     {
3193       startOperation( theCommandID );
3194       break;
3195     }
3196
3197   case SMESHOp::OpEditHypothesis:
3198     {
3199       if(isStudyLocked()) break;
3200
3201       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3202       SALOME_ListIO selected;
3203       if( aSel )
3204         aSel->selectedObjects( selected );
3205
3206       int nbSel = selected.Extent();
3207
3208       if (nbSel == 1) {
3209         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3210         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3211
3212         if ( !aHypothesis->_is_nil() )
3213         {
3214           SMESHGUI_GenericHypothesisCreator* aCreator =
3215             SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3216           if (aCreator)
3217           {
3218             // set geometry of mesh and sub-mesh to aCreator
3219             aSel->selectedObjects( selected, "",  /*convertReferences=*/false);
3220             if ( selected.Extent() == 1 )
3221             {
3222               QString subGeomID, meshGeomID;
3223               Handle(SALOME_InteractiveObject) hypIO = selected.First();
3224               if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3225               {
3226                 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3227                 aCreator->setShapeEntry( subGeomID );
3228                 aCreator->setMainShapeEntry( meshGeomID );
3229               }
3230             }
3231
3232             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3233           }
3234           else
3235           {
3236             // report error
3237           }
3238         }
3239       }
3240       break;
3241     }
3242   case SMESHOp::OpUnassign:                      // REMOVE HYPOTHESIS / ALGORITHMS
3243     {
3244       if(isStudyLocked()) break;
3245       SUIT_OverrideCursor wc;
3246
3247       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3248       SALOME_ListIO selected;
3249       if( aSel )
3250         aSel->selectedObjects( selected, QString::null, false );
3251
3252       SALOME_ListIteratorOfListIO It(selected);
3253       for (int i = 0; It.More(); It.Next(), i++) {
3254         Handle(SALOME_InteractiveObject) IObject = It.Value();
3255         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3256       }
3257       SALOME_ListIO l1;
3258       aSel->setSelectedObjects( l1 );
3259       updateObjBrowser();
3260       break;
3261     }
3262
3263   case SMESHOp::OpElem0D:
3264   case SMESHOp::OpBall:
3265   case SMESHOp::OpEdge:
3266   case SMESHOp::OpTriangle:
3267   case SMESHOp::OpQuadrangle:
3268   case SMESHOp::OpPolygon:
3269   case SMESHOp::OpTetrahedron:
3270   case SMESHOp::OpHexahedron:
3271   case SMESHOp::OpPentahedron:
3272   case SMESHOp::OpPyramid:
3273   case SMESHOp::OpHexagonalPrism:
3274     {
3275       if(isStudyLocked()) break;
3276       if ( vtkwnd ) {
3277         EmitSignalDeactivateDialog();
3278         SMDSAbs_EntityType type = SMDSEntity_Edge;
3279         switch (theCommandID) {
3280         case SMESHOp::OpElem0D: type = SMDSEntity_0D;                      break;
3281         case SMESHOp::OpBall: type = SMDSEntity_Ball;                      break;
3282         case SMESHOp::OpTriangle: type = SMDSEntity_Triangle;              break;
3283         case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle;          break;
3284         case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra;              break;
3285         case SMESHOp::OpPolygon: type = SMDSEntity_Polygon;                break;
3286         case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa;                break;
3287         case SMESHOp::OpPentahedron: type = SMDSEntity_Penta;              break;
3288         case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid;                break;
3289         case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3290         default:;
3291         }
3292         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3293       }
3294       else {
3295         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3296       }
3297       break;
3298     }
3299   case SMESHOp::OpPolyhedron:
3300     {
3301       if(isStudyLocked()) break;
3302       if ( vtkwnd ) {
3303         EmitSignalDeactivateDialog();
3304         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3305       }
3306       else {
3307         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3308       }
3309       break;
3310     }
3311   case SMESHOp::OpQuadraticEdge:
3312   case SMESHOp::OpQuadraticTriangle:
3313   case SMESHOp::OpBiQuadraticTriangle:
3314   case SMESHOp::OpQuadraticQuadrangle:
3315   case SMESHOp::OpBiQuadraticQuadrangle:
3316   case SMESHOp::OpQuadraticPolygon:
3317   case SMESHOp::OpQuadraticTetrahedron:
3318   case SMESHOp::OpQuadraticPyramid:
3319   case SMESHOp::OpQuadraticPentahedron:
3320   case SMESHOp::OpBiQuadraticPentahedron:
3321   case SMESHOp::OpQuadraticHexahedron:
3322   case SMESHOp::OpTriQuadraticHexahedron:
3323     {
3324       if(isStudyLocked()) break;
3325       if ( vtkwnd ) {
3326         EmitSignalDeactivateDialog();
3327         SMDSAbs_EntityType type = SMDSEntity_Last;
3328
3329         switch (theCommandID) {
3330         case SMESHOp::OpQuadraticEdge:          type = SMDSEntity_Quad_Edge; break;
3331         case SMESHOp::OpQuadraticTriangle:      type = SMDSEntity_Quad_Triangle; break;
3332         case SMESHOp::OpBiQuadraticTriangle:    type = SMDSEntity_BiQuad_Triangle; break;
3333         case SMESHOp::OpQuadraticQuadrangle:    type = SMDSEntity_Quad_Quadrangle; break;
3334         case SMESHOp::OpBiQuadraticQuadrangle:  type = SMDSEntity_BiQuad_Quadrangle; break;
3335         case SMESHOp::OpQuadraticPolygon:       type = SMDSEntity_Quad_Polygon; break;
3336         case SMESHOp::OpQuadraticTetrahedron:   type = SMDSEntity_Quad_Tetra; break;
3337         case SMESHOp::OpQuadraticPyramid:       type = SMDSEntity_Quad_Pyramid; break;
3338         case SMESHOp::OpQuadraticPentahedron:   type = SMDSEntity_Quad_Penta; break;
3339         case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3340         case SMESHOp::OpQuadraticHexahedron:    type = SMDSEntity_Quad_Hexa; break;
3341         case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3342         default: break;
3343         }
3344         if ( type != SMDSEntity_Last )
3345           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3346       }
3347       else {
3348         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3349                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3350       }
3351       break;
3352     }
3353   case SMESHOp::OpRemoveNodes:
3354     {
3355       if(isStudyLocked()) break;
3356       if ( vtkwnd ) {
3357         EmitSignalDeactivateDialog();
3358         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3359       }
3360       else {
3361         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3362                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3363       }
3364       break;
3365     }
3366   case SMESHOp::OpRemoveElements:                                    // REMOVES ELEMENTS
3367     {
3368       if(isStudyLocked()) break;
3369       if( vtkwnd ) {
3370         EmitSignalDeactivateDialog();
3371         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3372       }
3373       else
3374         {
3375           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3376                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3377         }
3378       break;
3379     }
3380   case SMESHOp::OpClearMesh: {
3381
3382     if(isStudyLocked()) break;
3383
3384     SALOME_ListIO selected;
3385     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3386       aSel->selectedObjects( selected );
3387
3388     SUIT_OverrideCursor wc;
3389     SALOME_ListIteratorOfListIO It (selected);
3390     for ( ; It.More(); It.Next() )
3391     {
3392       Handle(SALOME_InteractiveObject) IOS = It.Value();
3393       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3394       if ( aMesh->_is_nil()) continue;
3395       try {
3396         aMesh->Clear();
3397         if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3398           SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3399         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3400         // hide groups and submeshes
3401         _PTR(ChildIterator) anIter =
3402           SMESH::getStudy()->NewChildIterator( aMeshSObj );
3403         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3404         {
3405           _PTR(SObject) so = anIter->Value();
3406           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3407         }
3408       }
3409       catch (const SALOME::SALOME_Exception& S_ex){
3410         wc.suspend();
3411         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3412         wc.resume();
3413       }
3414     }
3415     SMESH::UpdateView();
3416     updateObjBrowser();
3417     break;
3418   }
3419   case SMESHOp::OpRemoveOrphanNodes:
3420     {
3421       if(isStudyLocked()) break;
3422       SALOME_ListIO selected;
3423       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3424         aSel->selectedObjects( selected );
3425       if ( selected.Extent() == 1 ) {
3426         Handle(SALOME_InteractiveObject) anIO = selected.First();
3427         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3428         if ( !aMesh->_is_nil() ) {
3429           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3430                                                     tr( "SMESH_WARNING" ),
3431                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3432                                                     SUIT_MessageBox::Yes |
3433                                                     SUIT_MessageBox::No,
3434                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3435           if( confirm ) {
3436             try {
3437               SUIT_OverrideCursor wc;
3438               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3439               int removed = aMeshEditor->RemoveOrphanNodes();
3440               SUIT_MessageBox::information(SMESHGUI::desktop(),
3441                                            tr("SMESH_INFORMATION"),
3442                                            tr("NB_NODES_REMOVED").arg(removed));
3443               if ( removed > 0 ) {
3444                 SMESH::UpdateView();
3445                 SMESHGUI::Modified();
3446               }
3447             }
3448             catch (const SALOME::SALOME_Exception& S_ex) {
3449               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3450             }
3451             catch (...) {
3452             }
3453           }
3454         }
3455       }
3456       break;
3457     }
3458   case SMESHOp::OpRenumberingNodes:
3459     {
3460       if(isStudyLocked()) break;
3461       if( vtkwnd ) {
3462         EmitSignalDeactivateDialog();
3463         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3464       }
3465       else
3466         {
3467           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3468                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3469         }
3470       break;
3471     }
3472   case SMESHOp::OpRenumberingElements:
3473     {
3474       if(isStudyLocked()) break;
3475       if ( vtkwnd ) {
3476         EmitSignalDeactivateDialog();
3477         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3478       }
3479       else
3480         {
3481           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3482                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3483         }
3484       break;
3485     }
3486   case SMESHOp::OpTranslation:
3487     {
3488       if(isStudyLocked()) break;
3489       if ( vtkwnd ) {
3490         EmitSignalDeactivateDialog();
3491         ( new SMESHGUI_TranslationDlg( this ) )->show();
3492       }
3493       else {
3494         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3495                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496       }
3497       break;
3498     }
3499   case SMESHOp::OpRotation:
3500     {
3501       if(isStudyLocked()) break;
3502       if( vtkwnd ) {
3503         EmitSignalDeactivateDialog();
3504         ( new SMESHGUI_RotationDlg( this ) )->show();
3505       }
3506       else {
3507         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3508                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3509       }
3510       break;
3511     }
3512   case SMESHOp::OpSymmetry:
3513     {
3514       if(isStudyLocked()) break;
3515       if(vtkwnd) {
3516         EmitSignalDeactivateDialog();
3517         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3518       }
3519       else {
3520         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3521                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3522       }
3523       break;
3524     }
3525   case SMESHOp::OpScale:
3526     {
3527       if(isStudyLocked()) break;
3528       if ( vtkwnd ) {
3529         EmitSignalDeactivateDialog();
3530         ( new SMESHGUI_ScaleDlg( this ) )->show();
3531       }
3532       else {
3533         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3534                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3535       }
3536       break;
3537     }
3538
3539   case SMESHOp::OpOffset:
3540     {
3541       if(isStudyLocked()) break;
3542       if ( vtkwnd ) {
3543         EmitSignalDeactivateDialog();
3544         ( new SMESHGUI_OffsetDlg( this ) )->show();
3545       }
3546       else {
3547         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3548                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3549       }
3550       break;
3551     }
3552
3553   case SMESHOp::OpSewing:
3554     {
3555       if(isStudyLocked()) break;
3556       if(vtkwnd) {
3557         EmitSignalDeactivateDialog();
3558         ( new SMESHGUI_SewingDlg( this ) )->show();
3559       }
3560       else {
3561         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3562                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3563       }
3564       break;
3565     }
3566   case SMESHOp::OpMergeNodes:
3567     {
3568       if(isStudyLocked()) break;
3569       if(vtkwnd) {
3570         EmitSignalDeactivateDialog();
3571         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3572       }
3573       else {
3574         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3575                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3576       }
3577       break;
3578     }
3579   case SMESHOp::OpMergeElements:
3580     {
3581       if (isStudyLocked()) break;
3582       if (vtkwnd) {
3583         EmitSignalDeactivateDialog();
3584         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3585       } else {
3586         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3587                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3588       }
3589       break;
3590     }
3591
3592   case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3593     startOperation( SMESHOp::OpMoveNode );
3594     break;
3595
3596   case SMESHOp::OpDuplicateNodes:
3597     {
3598       if(isStudyLocked()) break;
3599       if ( vtkwnd ) {
3600         EmitSignalDeactivateDialog();
3601         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3602       }
3603       else {
3604         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3605                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3606       }
3607       break;
3608     }
3609
3610   case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3611     startOperation( SMESHOp::OpElem0DOnElemNodes );
3612     break;
3613
3614   case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3615   {
3616     static QList<int> aTypes;
3617     if ( aTypes.isEmpty() )
3618     {
3619       aTypes.append( SMESH::NODE );
3620       aTypes.append( SMESH::EDGE );
3621       aTypes.append( SMESH::FACE );
3622       aTypes.append( SMESH::VOLUME );
3623     }
3624     if (!myFilterLibraryDlg)
3625       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3626     else if (myFilterLibraryDlg->isHidden())
3627       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3628     myFilterLibraryDlg->raise();
3629   }
3630   break;
3631   // CONTROLS
3632   case SMESHOp::OpFreeNode:
3633   case SMESHOp::OpEqualNode:
3634   case SMESHOp::OpNodeConnectivityNb:
3635   case SMESHOp::OpFreeEdge:
3636   case SMESHOp::OpFreeBorder:
3637   case SMESHOp::OpLength:
3638   case SMESHOp::OpConnection:
3639   case SMESHOp::OpEqualEdge:
3640   case SMESHOp::OpFreeFace:
3641   case SMESHOp::OpBareBorderFace:
3642   case SMESHOp::OpOverConstrainedFace:
3643   case SMESHOp::OpLength2D:
3644   case SMESHOp::OpDeflection2D:
3645   case SMESHOp::OpConnection2D:
3646   case SMESHOp::OpArea:
3647   case SMESHOp::OpTaper:
3648   case SMESHOp::OpAspectRatio:
3649   case SMESHOp::OpMinimumAngle:
3650   case SMESHOp::OpWarpingAngle:
3651   case SMESHOp::OpSkew:
3652   case SMESHOp::OpMaxElementLength2D:
3653   case SMESHOp::OpEqualFace:
3654   case SMESHOp::OpAspectRatio3D:
3655   case SMESHOp::OpVolume:
3656   case SMESHOp::OpMaxElementLength3D:
3657   case SMESHOp::OpBareBorderVolume:
3658   case SMESHOp::OpOverConstrainedVolume:
3659   case SMESHOp::OpEqualVolume:
3660     if ( vtkwnd ) {
3661
3662       LightApp_SelectionMgr* mgr = selectionMgr();
3663       SALOME_ListIO selected; mgr->selectedObjects( selected );
3664
3665       if( !selected.IsEmpty() ) {
3666         SUIT_OverrideCursor wc;
3667         ::Control( theCommandID );
3668         break;
3669       }
3670       SUIT_MessageBox::warning(desktop(),
3671                                tr( "SMESH_WRN_WARNING" ),
3672                                tr( "SMESH_BAD_SELECTION" ) );
3673       break;
3674     }
3675     else {
3676       SUIT_MessageBox::warning(desktop(),
3677                                tr( "SMESH_WRN_WARNING" ),
3678                                tr( "NOT_A_VTK_VIEWER" ) );
3679     }
3680     break;
3681   case SMESHOp::OpOverallMeshQuality:
3682     OverallMeshQuality();
3683     break;
3684   case SMESHOp::OpNumberingNodes:
3685     {
3686       SUIT_OverrideCursor wc;
3687       LightApp_SelectionMgr* mgr = selectionMgr();
3688       SALOME_ListIO selected; mgr->selectedObjects( selected );
3689
3690       SALOME_ListIteratorOfListIO it(selected);
3691       for( ; it.More(); it.Next()) {
3692         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3693         if(anIObject->hasEntry()) {
3694           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3695             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3696           }
3697         }
3698       }
3699       break;
3700     }
3701   case SMESHOp::OpNumberingElements:
3702     {
3703       SUIT_OverrideCursor wc;
3704       LightApp_SelectionMgr* mgr = selectionMgr();
3705       SALOME_ListIO selected; mgr->selectedObjects( selected );
3706
3707       SALOME_ListIteratorOfListIO it(selected);
3708       for( ; it.More(); it.Next()) {
3709         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3710         if(anIObject->hasEntry())
3711           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3712             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3713           }
3714       }
3715       break;
3716     }
3717   case SMESHOp::OpPropertiesLength:
3718   case SMESHOp::OpPropertiesArea:
3719   case SMESHOp::OpPropertiesVolume:
3720   case SMESHOp::OpMinimumDistance:
3721   case SMESHOp::OpBoundingBox:
3722   case SMESHOp::OpAngle:
3723     {
3724       int page = SMESHGUI_MeasureDlg::MinDistance;
3725       if ( theCommandID == SMESHOp::OpBoundingBox )
3726         page = SMESHGUI_MeasureDlg::BoundingBox;
3727       else if ( theCommandID == SMESHOp::OpPropertiesLength )
3728         page = SMESHGUI_MeasureDlg::Length;
3729       else if ( theCommandID == SMESHOp::OpPropertiesArea )
3730         page = SMESHGUI_MeasureDlg::Area;
3731       else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3732         page = SMESHGUI_MeasureDlg::Volume;
3733       else if ( theCommandID == SMESHOp::OpAngle )
3734         page = SMESHGUI_MeasureDlg::Angle;
3735
3736       EmitSignalDeactivateDialog();
3737       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3738       dlg->show();
3739       break;
3740     }
3741   case SMESHOp::OpSortChild:
3742     ::sortChildren();
3743     break;
3744
3745   }
3746
3747   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3748   //updateObjBrowser();
3749   return true;
3750 }
3751
3752 //=============================================================================
3753 /*!
3754  *
3755  */
3756 //=============================================================================
3757 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3758 {
3759   return false;
3760 }
3761
3762 //=============================================================================
3763 /*!
3764  *
3765  */
3766 //=============================================================================
3767 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3768 {
3769   return true;
3770 }
3771
3772 //=============================================================================
3773 /*!
3774  *
3775  */
3776 //=============================================================================
3777 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3778 {
3779   return true;
3780 }
3781
3782 //=============================================================================
3783 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3784  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3785  */
3786 //=============================================================================
3787 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3788                                   SUIT_ViewWindow* wnd )
3789 {
3790   if(theIO->hasEntry()){
3791     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3792     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3793   }
3794 }
3795
3796 //=======================================================================
3797 // function : createSMESHAction
3798 // purpose  :
3799 //=======================================================================
3800 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3801                                   const int key, const bool toggle, const QString& shortcutAction  )
3802 {
3803   QIcon icon;
3804   QWidget* parent = application()->desktop();
3805   SUIT_ResourceMgr* resMgr = resourceMgr();
3806   QPixmap pix;
3807   if ( !icon_id.isEmpty() )
3808     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3809   else
3810     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3811   if ( !pix.isNull() )
3812     icon = QIcon( pix );
3813
3814   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3815           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3816           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3817
3818   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3819                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3820 }
3821
3822 //=======================================================================
3823 // function : createPopupItem
3824 // purpose  :
3825 //=======================================================================
3826 void SMESHGUI::createPopupItem( const int id,
3827                                 const QString& clients,
3828                                 const QString& types,
3829                                 const QString& theRule,
3830                                 const int pId )
3831 {
3832   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3833     popupMgr()->insert( action( id ), pId, 0 );
3834
3835   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3836   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3837   QString rule = "(%1) and (%2) and (%3)";
3838   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3839   if( clients.isEmpty() )
3840     rule = rule.arg( QString( "true" ) );
3841   else
3842     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3843   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3844   rule += theRule;
3845
3846   bool cont = myRules.contains( id );
3847   if( cont )
3848     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3849
3850   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3851   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3852 }
3853
3854 //=======================================================================
3855 // function : initialize
3856 // purpose  :
3857 //=======================================================================
3858 void SMESHGUI::initialize( CAM_Application* app )
3859 {
3860   SalomeApp_Module::initialize( app );
3861
3862 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3863 //   if ( mgr )
3864   /* Automatic Update flag */
3865 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3866
3867   // ----- create actions --------------
3868
3869   //createSMESHAction(  SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3870   createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3871   createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3872   createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL"  );
3873 #ifdef WITH_CGNS
3874   createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3875 #endif
3876   createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3877   createSMESHAction( SMESHOp::OpImportGMF,  "IMPORT_GMF"  );
3878   createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3879   createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3880   createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL"  );
3881 #ifdef WITH_CGNS
3882   createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3883 #endif
3884   createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3885   createSMESHAction( SMESHOp::OpPopupImportGMF,  "IMPORT_GMF"  );
3886
3887   createSMESHAction( SMESHOp::OpExportDAT,  "DAT" );
3888   createSMESHAction( SMESHOp::OpExportMED,  "MED" );
3889   createSMESHAction( SMESHOp::OpExportUNV,  "UNV" );
3890   createSMESHAction( SMESHOp::OpExportSTL,  "STL" );
3891 #ifdef WITH_CGNS
3892   createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3893 #endif
3894   createSMESHAction( SMESHOp::OpExportSAUV,     "SAUV");
3895   createSMESHAction( SMESHOp::OpExportGMF,      "GMF" );
3896   createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3897   createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3898   createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3899   createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3900 #ifdef WITH_CGNS
3901   createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3902 #endif
3903   createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3904   createSMESHAction( SMESHOp::OpPopupExportGMF,  "GMF" );
3905   createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3906   createSMESHAction( SMESHOp::OpDelete,          "DELETE", "ICON_DELETE", Qt::Key_Delete );
3907   createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3908   createSMESHAction( SMESHOp::OpCreateMesh,           "CREATE_MESH",             "ICON_DLG_INIT_MESH" );
3909   createSMESHAction( SMESHOp::OpCreateSubMesh,        "CREATE_SUBMESH",          "ICON_DLG_ADD_SUBMESH" );
3910   createSMESHAction( SMESHOp::OpEditMeshOrSubMesh,    "EDIT_MESHSUBMESH",        "ICON_DLG_EDIT_MESH" );
3911   createSMESHAction( SMESHOp::OpEditMesh,             "EDIT_MESH",               "ICON_DLG_EDIT_MESH" );
3912   createSMESHAction( SMESHOp::OpEditSubMesh,          "EDIT_SUBMESH",            "ICON_DLG_EDIT_MESH" );
3913   createSMESHAction( SMESHOp::OpBuildCompoundMesh,    "BUILD_COMPOUND",          "ICON_BUILD_COMPOUND" );
3914   createSMESHAction( SMESHOp::OpCopyMesh,             "COPY_MESH",               "ICON_COPY_MESH" );
3915   createSMESHAction( SMESHOp::OpCompute,              "COMPUTE",                 "ICON_COMPUTE" );
3916   createSMESHAction( SMESHOp::OpComputeSubMesh,       "COMPUTE_SUBMESH",         "ICON_COMPUTE" );
3917   createSMESHAction( SMESHOp::OpPreCompute,           "PRECOMPUTE",              "ICON_PRECOMPUTE" );
3918   createSMESHAction( SMESHOp::OpEvaluate,             "EVALUATE",                "ICON_EVALUATE" );
3919   createSMESHAction( SMESHOp::OpMeshOrder,            "MESH_ORDER",              "ICON_MESH_ORDER");
3920   createSMESHAction( SMESHOp::OpCreateGroup,          "CREATE_GROUP",            "ICON_CREATE_GROUP" );
3921   createSMESHAction( SMESHOp::OpCreateGeometryGroup,  "CREATE_GEO_GROUP",        "ICON_CREATE_GEO_GROUP" );
3922   createSMESHAction( SMESHOp::OpConstructGroup,       "CONSTRUCT_GROUP",         "ICON_CONSTRUCT_GROUP" );
3923   createSMESHAction( SMESHOp::OpEditGroup,            "EDIT_GROUP",              "ICON_EDIT_GROUP" );
3924   createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3925   createSMESHAction( SMESHOp::OpUnionGroups,          "UN_GROUP",                "ICON_UNION" );
3926   createSMESHAction( SMESHOp::OpIntersectGroups,      "INT_GROUP",               "ICON_INTERSECT" );
3927   createSMESHAction( SMESHOp::OpCutGroups,            "CUT_GROUP",               "ICON_CUT" );
3928   createSMESHAction( SMESHOp::OpGroupUnderlyingElem,  "UNDERLYING_ELEMS",        "ICON_UNDERLYING_ELEMS" );
3929   createSMESHAction( SMESHOp::OpFaceGroupsByEdges,    "FACE_GROUPS_BY_EDGES",    "ICON_FACE_GROUPS_BY_EDGES" );
3930   createSMESHAction( SMESHOp::OpAddElemGroupPopup,    "ADD_TO_GROUP" );
3931   createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3932   createSMESHAction( SMESHOp::OpDeleteGroup,          "DEL_GROUP",               "ICON_DEL_GROUP" );
3933   createSMESHAction( SMESHOp::OpMeshInformation ,     "ADV_INFO",                "ICON_ADV_INFO" );
3934   //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO",        "ICON_STD_INFO" );
3935   //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3936   createSMESHAction( SMESHOp::OpFindElementByPoint,   "FIND_ELEM",               "ICON_FIND_ELEM" );
3937   //update
3938   createSMESHAction( SMESHOp::OpFreeNode,              "FREE_NODE",               "ICON_FREE_NODE",     0, true );
3939   createSMESHAction( SMESHOp::OpEqualNode,             "EQUAL_NODE",              "ICON_EQUAL_NODE",    0, true );
3940   createSMESHAction( SMESHOp::OpNodeConnectivityNb,    "NODE_CONNECTIVITY_NB",    "ICON_NODE_CONN_NB",    0, true );
3941   createSMESHAction( SMESHOp::OpFreeEdge,              "FREE_EDGE",               "ICON_FREE_EDGE",     0, true );
3942   createSMESHAction( SMESHOp::OpFreeBorder,            "FREE_BORDER",             "ICON_FREE_EDGE_2D",  0, true );
3943   createSMESHAction( SMESHOp::OpLength,                "LENGTH",                  "ICON_LENGTH",        0, true );
3944   createSMESHAction( SMESHOp::OpConnection,            "CONNECTION",              "ICON_CONNECTION",    0, true );
3945   createSMESHAction( SMESHOp::OpEqualEdge,             "EQUAL_EDGE",              "ICON_EQUAL_EDGE",    0, true );
3946   createSMESHAction( SMESHOp::OpFreeFace,              "FREE_FACES",              "ICON_FREE_FACES",    0, true );
3947   createSMESHAction( SMESHOp::OpBareBorderFace,        "BARE_BORDER_FACE",        "ICON_BARE_BORDER_FACE",        0, true );
3948   createSMESHAction( SMESHOp::OpOverConstrainedFace,   "OVER_CONSTRAINED_FACE",   "ICON_OVER_CONSTRAINED_FACE",   0, true );
3949   createSMESHAction( SMESHOp::OpLength2D,              "LENGTH_2D",               "ICON_LENGTH_2D",     0, true );
3950   createSMESHAction( SMESHOp::OpDeflection2D,          "DEFLECTION_2D",           "ICON_DEFLECTION_2D", 0, true );
3951   createSMESHAction( SMESHOp::OpConnection2D,          "CONNECTION_2D",           "ICON_CONNECTION_2D", 0, true );
3952   createSMESHAction( SMESHOp::OpArea,                  "AREA",                    "ICON_AREA",          0, true );
3953   createSMESHAction( SMESHOp::OpTaper,                 "TAPER",                   "ICON_TAPER",         0, true );
3954   createSMESHAction( SMESHOp::OpAspectRatio,           "ASPECT",                  "ICON_ASPECT",        0, true );
3955   createSMESHAction( SMESHOp::OpMinimumAngle,          "MIN_ANG",                 "ICON_ANGLE",         0, true );
3956   createSMESHAction( SMESHOp::OpWarpingAngle,          "WARP",                    "ICON_WARP",          0, true );
3957   createSMESHAction( SMESHOp::OpSkew,                  "SKEW",                    "ICON_SKEW",          0, true );
3958   createSMESHAction( SMESHOp::OpMaxElementLength2D,    "MAX_ELEMENT_LENGTH_2D",   "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
3959   createSMESHAction( SMESHOp::OpEqualFace,             "EQUAL_FACE",              "ICON_EQUAL_FACE",    0, true );
3960   createSMESHAction( SMESHOp::OpAspectRatio3D,         "ASPECT_3D",               "ICON_ASPECT_3D",     0, true );
3961   createSMESHAction( SMESHOp::OpVolume,                "VOLUME_3D",               "ICON_VOLUME_3D",     0, true );
3962   createSMESHAction( SMESHOp::OpMaxElementLength3D,    "MAX_ELEMENT_LENGTH_3D",   "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
3963   createSMESHAction( SMESHOp::OpBareBorderVolume,      "BARE_BORDER_VOLUME",      "ICON_BARE_BORDER_VOLUME",      0, true );
3964   createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3965   createSMESHAction( SMESHOp::OpEqualVolume,           "EQUAL_VOLUME",            "ICON_EQUAL_VOLUME",  0, true );
3966   createSMESHAction( SMESHOp::OpOverallMeshQuality,    "OVERALL_MESH_QUALITY",    "ICON_OVL_MESH_QUALITY" );
3967
3968   createSMESHAction( SMESHOp::OpNode,                   "NODE",            "ICON_DLG_NODE" );
3969   createSMESHAction( SMESHOp::OpElem0D,                 "ELEM0D",          "ICON_DLG_ELEM0D" );
3970   createSMESHAction( SMESHOp::OpElem0DOnElemNodes,      "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3971   createSMESHAction( SMESHOp::OpBall,                   "BALL",            "ICON_DLG_BALL" );
3972   createSMESHAction( SMESHOp::OpEdge,                   "EDGE",            "ICON_DLG_EDGE" );
3973   createSMESHAction( SMESHOp::OpTriangle,               "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3974   createSMESHAction( SMESHOp::OpQuadrangle,             "QUAD",            "ICON_DLG_QUADRANGLE" );
3975   createSMESHAction( SMESHOp::OpPolygon,                "POLYGON",         "ICON_DLG_POLYGON" );
3976   createSMESHAction( SMESHOp::OpTetrahedron,            "TETRA",           "ICON_DLG_TETRAS" );
3977   createSMESHAction( SMESHOp::OpHexahedron,             "HEXA",            "ICON_DLG_HEXAS" );
3978   createSMESHAction( SMESHOp::OpPentahedron,            "PENTA",           "ICON_DLG_PENTA" );
3979   createSMESHAction( SMESHOp::OpPyramid ,               "PYRAMID",         "ICON_DLG_PYRAMID" );
3980   createSMESHAction( SMESHOp::OpHexagonalPrism,         "OCTA",            "ICON_DLG_OCTA" );
3981   createSMESHAction( SMESHOp::OpPolyhedron,             "POLYHEDRON",      "ICON_DLG_POLYHEDRON" );
3982   createSMESHAction( SMESHOp::OpQuadraticEdge,          "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
3983   createSMESHAction( SMESHOp::OpQuadraticTriangle,      "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
3984   createSMESHAction( SMESHOp::OpBiQuadraticTriangle,    "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3985   createSMESHAction( SMESHOp::OpQuadraticQuadrangle,    "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
3986   createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle,  "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3987   createSMESHAction( SMESHOp::OpQuadraticPolygon,       "QUADRATIC_POLYGON",       "ICON_DLG_QUADRATIC_POLYGON" );
3988   createSMESHAction( SMESHOp::OpQuadraticTetrahedron,   "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3989   createSMESHAction( SMESHOp::OpQuadraticPyramid,       "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
3990   createSMESHAction( SMESHOp::OpQuadraticPentahedron,   "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3991   createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3992   createSMESHAction( SMESHOp::OpQuadraticHexahedron,    "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3993   createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3994
3995   createSMESHAction( SMESHOp::OpRemoveNodes,       "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
3996   createSMESHAction( SMESHOp::OpRemoveElements,    "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
3997   createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
3998   createSMESHAction( SMESHOp::OpClearMesh,         "CLEAR_MESH",            "ICON_CLEAR_MESH" );
3999
4000   //createSMESHAction( SMESHOp::OpRenumberingNodes,    "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
4001   //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
4002
4003   createSMESHAction( SMESHOp::OpTranslation,            "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
4004   createSMESHAction( SMESHOp::OpRotation,               "ROT",             "ICON_DLG_MESH_ROTATION" );
4005   createSMESHAction( SMESHOp::OpSymmetry,               "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
4006   createSMESHAction( SMESHOp::OpScale,                  "SCALE",           "ICON_DLG_MESH_SCALE" );
4007   createSMESHAction( SMESHOp::OpOffset,                 "OFFSET",          "ICON_DLG_MESH_OFFSET" );
4008   createSMESHAction( SMESHOp::OpSewing,                 "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
4009   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
4010   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
4011   createSMESHAction( SMESHOp::OpMoveNode,               "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4012   createSMESHAction( SMESHOp::OpDuplicateNodes,         "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4013   createSMESHAction( SMESHOp::OpDiagonalInversion,      "INV",             "ICON_DLG_MESH_DIAGONAL" );
4014   createSMESHAction( SMESHOp::OpUnionOfTwoTriangle,     "UNION2",          "ICON_UNION2TRI" );
4015   createSMESHAction( SMESHOp::OpOrientation,            "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
4016   createSMESHAction( SMESHOp::OpReorientFaces,          "REORIENT_2D",     "ICON_REORIENT_2D" );
4017   createSMESHAction( SMESHOp::OpUnionOfTriangles,       "UNION",           "ICON_UNIONTRI" );
4018   createSMESHAction( SMESHOp::OpCuttingOfQuadrangles,   "CUT",             "ICON_CUTQUAD" );
4019   createSMESHAction( SMESHOp::OpSplitVolumes,           "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
4020   createSMESHAction( SMESHOp::OpSplitBiQuadratic,       "SPLIT_BIQUAD",    "ICON_SPLIT_BIQUAD" );
4021   createSMESHAction( SMESHOp::OpSmoothing,              "SMOOTH",          "ICON_DLG_SMOOTHING" );
4022   createSMESHAction( SMESHOp::OpExtrusion,              "EXTRUSION",       "ICON_EXTRUSION" );
4023   createSMESHAction( SMESHOp::OpExtrusionAlongAPath,    "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4024   createSMESHAction( SMESHOp::OpRevolution,             "REVOLUTION",      "ICON_REVOLUTION" );
4025   createSMESHAction( SMESHOp::OpPatternMapping,         "MAP",             "ICON_MAP" );
4026   createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
4027   createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
4028
4029   createSMESHAction( SMESHOp::OpReset,               "RESET" );
4030   createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4031   createSMESHAction( SMESHOp::OpShowScalarBar,       "SHOW_SCALAR_BAR","",0, true  );
4032   createSMESHAction( SMESHOp::OpSaveDistribution,    "SAVE_DISTRIBUTION" );
4033   createSMESHAction( SMESHOp::OpShowDistribution,    "SHOW_DISTRIBUTION","",0, true );
4034 #ifndef DISABLE_PLOT2DVIEWER
4035   createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4036 #endif
4037   createSMESHAction( SMESHOp::OpDMWireframe,  "WIRE",    "ICON_WIRE", 0, true );
4038   createSMESHAction( SMESHOp::OpDMShading,    "SHADE",   "ICON_SHADE", 0, true );
4039   createSMESHAction( SMESHOp::OpDMNodes,      "NODES",   "ICON_POINTS", 0, true );
4040   createSMESHAction( SMESHOp::OpDMShrink,     "SHRINK",  "ICON_SHRINK", 0, true );
4041   createSMESHAction( SMESHOp::OpUpdate,       "UPDATE",  "ICON_UPDATE" );
4042   createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4043   createSMESHAction( SMESHOp::OpDEEdges,      "EDGES",   "ICON_DLG_EDGE", 0, true );
4044   createSMESHAction( SMESHOp::OpDEFaces,      "FACES",   "ICON_DLG_TRIANGLE", 0, true );
4045   createSMESHAction( SMESHOp::OpDEVolumes,    "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4046   createSMESHAction( SMESHOp::OpDEBalls,      "BALLS",   "ICON_DLG_BALL", 0, true );
4047   createSMESHAction( SMESHOp::OpDEChoose,     "CHOOSE",  "ICON_DLG_CHOOSE", 0, false );
4048   createSMESHAction( SMESHOp::OpDEAllEntity,  "ALL",     "ICON_DLG_CHOOSE_ALL", 0, false );
4049   createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4050
4051   createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4052   createSMESHAction( SMESHOp::OpRepresentationArcs,  "ARC_REPRESENTATION", "", 0, true );
4053
4054   createSMESHAction( SMESHOp::OpEditHypothesis,    "EDIT_HYPO" );
4055   createSMESHAction( SMESHOp::OpUnassign,          "UNASSIGN" );
4056   createSMESHAction( SMESHOp::OpNumberingNodes,    "NUM_NODES", "", 0, true );
4057   createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4058   createSMESHAction( SMESHOp::OpProperties,   "COLORS" );
4059   createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4060   createSMESHAction( SMESHOp::OpClipping,     "CLIP" );
4061   createSMESHAction( SMESHOp::OpAutoColor,        "AUTO_COLOR" );
4062   createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4063
4064   createSMESHAction( SMESHOp::OpMinimumDistance,  "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4065   createSMESHAction( SMESHOp::OpBoundingBox,      "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
4066   createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH",   "ICON_MEASURE_LENGTH" );
4067   createSMESHAction( SMESHOp::OpPropertiesArea,   "MEASURE_AREA",     "ICON_MEASURE_AREA" );
4068   createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME",   "ICON_MEASURE_VOLUME" );
4069   createSMESHAction( SMESHOp::OpAngle,            "MEASURE_ANGLE",    "ICON_MEASURE_ANGLE" );
4070
4071   createSMESHAction( SMESHOp::OpHide,     "HIDE", "ICON_HIDE" );
4072   createSMESHAction( SMESHOp::OpShow,     "SHOW", "ICON_SHOW" );
4073   createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4074
4075   createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4076
4077   QList<int> aCtrlActions;
4078   aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4079                << SMESHOp::OpNodeConnectivityNb                                         // node controls
4080                << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4081                << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge    // edge controls
4082                << SMESHOp::OpDeflection2D
4083                << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4084                << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4085                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4086                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4087                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
4088                << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4089                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4090                << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
4091   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4092   aCtrlGroup->setExclusive( true );
4093   for( int i = 0; i < aCtrlActions.size(); i++ )
4094     aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4095
4096   // ----- create menu --------------
4097   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
4098       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
4099       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
4100       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
4101       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
4102       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
4103       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4104       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
4105
4106   createMenu( separator(), fileId );
4107
4108   QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4109   QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4110   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4111       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4112       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4113       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4114       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4115       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4116       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
4117       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4118     //renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
4119       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4120       basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4121
4122   //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4123   createMenu( SMESHOp::OpImportUNV,  importId, -1 );
4124   createMenu( SMESHOp::OpImportMED,  importId, -1 );
4125   createMenu( SMESHOp::OpImportSTL,  importId, -1 );
4126 #ifdef WITH_CGNS
4127   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4128 #endif
4129   createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4130   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
4131   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
4132   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
4133   createMenu( SMESHOp::OpExportUNV,  exportId, -1 );
4134   createMenu( SMESHOp::OpExportSTL,  exportId, -1 );
4135 #ifdef WITH_CGNS
4136   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4137 #endif
4138   createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4139   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
4140   createMenu( separator(), fileId, 10 );
4141
4142   createMenu( SMESHOp::OpDelete, editId, -1 );
4143
4144   createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4145
4146   createMenu( SMESHOp::OpCreateMesh,           meshId, -1 ); // "Mesh" menu
4147   createMenu( SMESHOp::OpCreateSubMesh,        meshId, -1 );
4148   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
4149   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
4150   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
4151   createMenu( separator(),                     meshId, -1 );
4152   createMenu( SMESHOp::OpCompute,              meshId, -1 );
4153   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
4154   createMenu( SMESHOp::OpEvaluate,             meshId, -1 );
4155   createMenu( SMESHOp::OpMeshOrder,            meshId, -1 );
4156   createMenu( separator(),                     meshId, -1 );
4157   createMenu( SMESHOp::OpCreateGroup,          meshId, -1 );
4158   createMenu( SMESHOp::OpCreateGeometryGroup,  meshId, -1 );
4159   createMenu( SMESHOp::OpConstructGroup,       meshId, -1 );
4160   createMenu( SMESHOp::OpEditGroup,            meshId, -1 );
4161   createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4162   createMenu( separator(),                     meshId, -1 );
4163   createMenu( SMESHOp::OpUnionGroups,          meshId, -1 );
4164   createMenu( SMESHOp::OpIntersectGroups,      meshId, -1 );
4165   createMenu( SMESHOp::OpCutGroups,            meshId, -1 );
4166   createMenu( separator(),                     meshId, -1 );
4167   createMenu( SMESHOp::OpGroupUnderlyingElem,  meshId, -1 );
4168   createMenu( SMESHOp::OpFaceGroupsByEdges,    meshId, -1 );
4169   createMenu( separator(),                     meshId, -1 );
4170   createMenu( SMESHOp::OpMeshInformation,      meshId, -1 );
4171   //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4172   //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4173   createMenu( SMESHOp::OpFindElementByPoint,   meshId, -1 );
4174   createMenu( separator(),                     meshId, -1 );
4175
4176   createMenu( SMESHOp::OpFreeNode,              nodeId,   -1 );
4177   createMenu( SMESHOp::OpEqualNode,             nodeId,   -1 );
4178   //createMenu( SMESHOp::OpNodeConnectivityNb,    nodeId,   -1 );
4179   createMenu( SMESHOp::OpFreeBorder,            edgeId,   -1 );
4180   createMenu( SMESHOp::OpLength,                edgeId,   -1 );
4181   createMenu( SMESHOp::OpConnection,            edgeId,   -1 );
4182   createMenu( SMESHOp::OpEqualEdge,             edgeId,   -1 );
4183   createMenu( SMESHOp::OpFreeEdge,              faceId,   -1 );
4184   createMenu( SMESHOp::OpFreeFace,              faceId,   -1 );
4185   createMenu( SMESHOp::OpBareBorderFace,        faceId,   -1 );
4186   createMenu( SMESHOp::OpOverConstrainedFace,   faceId,   -1 );
4187   createMenu( SMESHOp::OpLength2D,              faceId,   -1 );
4188   createMenu( SMESHOp::OpConnection2D,          faceId,   -1 );
4189   createMenu( SMESHOp::OpArea,                  faceId,   -1 );
4190   createMenu( SMESHOp::OpTaper,                 faceId,   -1 );
4191   createMenu( SMESHOp::OpAspectRatio,           faceId,   -1 );
4192   createMenu( SMESHOp::OpMinimumAngle,          faceId,   -1 );
4193   createMenu( SMESHOp::OpWarpingAngle,          faceId,   -1 );
4194   createMenu( SMESHOp::OpSkew,                  faceId,   -1 );
4195   createMenu( SMESHOp::OpMaxElementLength2D,    faceId,   -1 );
4196   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
4197   createMenu( SMESHOp::OpDeflection2D,          faceId,   -1 );
4198   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
4199   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
4200   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
4201   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
4202   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4203   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
4204   createMenu( separator(),                      ctrlId,   -1 );
4205   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
4206   createMenu( separator(),                      ctrlId,   -1 );
4207   createMenu( SMESHOp::OpOverallMeshQuality,    ctrlId,   -1 );
4208
4209   createMenu( SMESHOp::OpNode,                   addId, -1 );
4210   createMenu( SMESHOp::OpElem0D,                 addId, -1 );
4211   createMenu( SMESHOp::OpElem0DOnElemNodes,      addId, -1 );
4212   createMenu( SMESHOp::OpBall,                   addId, -1 );
4213   createMenu( SMESHOp::OpEdge,                   addId, -1 );
4214   createMenu( SMESHOp::OpTriangle,               addId, -1 );
4215   createMenu( SMESHOp::OpQuadrangle,             addId, -1 );
4216   createMenu( SMESHOp::OpPolygon,                addId, -1 );
4217   createMenu( SMESHOp::OpTetrahedron,            addId, -1 );
4218   createMenu( SMESHOp::OpHexahedron,             addId, -1 );
4219   createMenu( SMESHOp::OpPentahedron,            addId, -1 );
4220   createMenu( SMESHOp::OpPyramid,                addId, -1 );
4221   createMenu( SMESHOp::OpHexagonalPrism,         addId, -1 );
4222   createMenu( SMESHOp::OpPolyhedron,             addId, -1 );
4223   createMenu( separator(),                       addId, -1 );
4224   createMenu( SMESHOp::OpQuadraticEdge,          addId, -1 );
4225   createMenu( SMESHOp::OpQuadraticTriangle,      addId, -1 );
4226   createMenu( SMESHOp::OpBiQuadraticTriangle ,   addId, -1 );
4227   createMenu( SMESHOp::OpQuadraticQuadrangle,    addId, -1 );
4228   createMenu( SMESHOp::OpBiQuadraticQuadrangle,  addId, -1 );
4229   createMenu( SMESHOp::OpQuadraticPolygon,       addId, -1 );
4230   createMenu( SMESHOp::OpQuadraticTetrahedron,   addId, -1 );
4231   createMenu( SMESHOp::OpQuadraticPyramid,       addId, -1 );
4232   createMenu( SMESHOp::OpQuadraticPentahedron,   addId, -1 );
4233   createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4234   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
4235   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4236
4237   createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
4238   createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
4239   createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4240   createMenu( separator(),                  removeId, -1 );
4241   createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
4242   createMenu( separator(),                  removeId, -1 );
4243   createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
4244
4245   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
4246   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4247
4248   createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
4249   createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
4250   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
4251   createMenu( SMESHOp::OpRotation,       transfId, -1 );
4252   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
4253   createMenu( SMESHOp::OpScale,          transfId, -1 );
4254   createMenu( SMESHOp::OpOffset,         transfId, -1 );
4255   createMenu( SMESHOp::OpSewing,         transfId, -1 );
4256   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4257
4258   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4259   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4260   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
4261   createMenu( SMESHOp::OpExtrusionAlongAPath,    modifyId, -1 );
4262   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
4263   createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
4264   createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
4265   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
4266   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
4267   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
4268   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
4269   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
4270   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
4271   createMenu( SMESHOp::OpSplitBiQuadratic,       modifyId, -1 );
4272   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
4273   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
4274
4275   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
4276   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
4277   createMenu( SMESHOp::OpAngle,            measureId,   -1 );
4278   createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4279   createMenu( SMESHOp::OpPropertiesArea,   basicPropId, -1 );
4280   createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4281   createMenu( SMESHOp::OpUpdate,           viewId,      -1 );
4282
4283   connect( nodeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4284   connect( edgeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4285   connect( faceMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4286   connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4287
4288   // ----- create toolbars --------------
4289   int meshTb       = createTool( tr( "TB_MESH" ),      QString( "SMESHMeshToolbar" ) ),
4290       info         = createTool( tr( "TB_INFO" ),      QString( "SMESHInformationToolbar" ) ),
4291       groupTb      = createTool( tr( "TB_GROUP" ),     QString( "SMESHGroupToolbar" ) ),
4292       ctrl0dTb     = createTool( tr( "TB_CTRL0D" ),    QString( "SMESHNodeControlsToolbar" ) ),
4293       ctrl1dTb     = createTool( tr( "TB_CTRL1D" ),    QString( "SMESHEdgeControlsToolbar" ) ),
4294       ctrl2dTb     = createTool( tr( "TB_CTRL2D" ),    QString( "SMESHFaceControlsToolbar" ) ),
4295       ctrl3dTb     = createTool( tr( "TB_CTRL3D" ),    QString( "SMESHVolumeControlsToolbar" ) ),
4296       addElemTb    = createTool( tr( "TB_ADD" ),       QString( "SMESHAddElementToolbar" ) ),
4297       addNonElemTb = createTool( tr( "TB_ADDNON" ),    QString( "SMESHAddElementToolbar" ) ),
4298       remTb        = createTool( tr( "TB_REM" ),       QString( "SMESHRemoveToolbar" ) ),
4299     //renumbTb     = createTool( tr( "TB_RENUMBER" ),  QString( "SMESHRenumberingToolbar" ) ),
4300       transformTb  = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4301       modifyTb     = createTool( tr( "TB_MODIFY" ),    QString( "SMESHModificationToolbar" ) ),
4302       measuremTb   = createTool( tr( "TB_MEASUREM" ),  QString( "SMESHMeasurementsToolbar" ) ),
4303       dispModeTb   = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4304
4305   createTool( SMESHOp::OpCreateMesh,        meshTb );
4306   createTool( SMESHOp::OpCreateSubMesh,     meshTb );
4307   createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4308   createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4309   createTool( SMESHOp::OpCopyMesh,          meshTb );
4310   createTool( separator(),                  meshTb );
4311   createTool( SMESHOp::OpCompute,           meshTb );
4312   createTool( SMESHOp::OpPreCompute,        meshTb );
4313   createTool( SMESHOp::OpEvaluate,          meshTb );
4314   createTool( SMESHOp::OpMeshOrder,         meshTb );
4315
4316   createTool( SMESHOp::OpCreateGroup,         groupTb );
4317   createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4318   createTool( SMESHOp::OpConstructGroup,      groupTb );
4319   createTool( SMESHOp::OpEditGroup,           groupTb );
4320
4321   createTool( SMESHOp::OpMeshInformation,    info );
4322   //createTool( SMESHOp::OpStdInfo, meshTb );
4323   //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4324   createTool( SMESHOp::OpFindElementByPoint, info );
4325
4326   createTool( SMESHOp::OpFreeNode,  ctrl0dTb );
4327   createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4328   //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4329
4330   createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4331   createTool( SMESHOp::OpLength,     ctrl1dTb );
4332   createTool( SMESHOp::OpConnection, ctrl1dTb );
4333   createTool( SMESHOp::OpEqualEdge,  ctrl1dTb );
4334
4335   createTool( SMESHOp::OpFreeEdge,            ctrl2dTb );
4336   createTool( SMESHOp::OpFreeFace,            ctrl2dTb );
4337   createTool( SMESHOp::OpBareBorderFace,      ctrl2dTb );
4338   createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4339   createTool( SMESHOp::OpLength2D,            ctrl2dTb );
4340   createTool( SMESHOp::OpConnection2D,        ctrl2dTb );
4341   createTool( SMESHOp::OpArea,                ctrl2dTb );
4342   createTool( SMESHOp::OpTaper,               ctrl2dTb );
4343   createTool( SMESHOp::OpAspectRatio,         ctrl2dTb );
4344   createTool( SMESHOp::OpMinimumAngle,        ctrl2dTb );
4345   createTool( SMESHOp::OpWarpingAngle,        ctrl2dTb );
4346   createTool( SMESHOp::OpSkew,                ctrl2dTb );
4347   createTool( SMESHOp::OpMaxElementLength2D,  ctrl2dTb );
4348   createTool( SMESHOp::OpEqualFace,           ctrl2dTb );
4349   createTool( SMESHOp::OpDeflection2D,        ctrl2dTb );
4350
4351   createTool( SMESHOp::OpAspectRatio3D,         ctrl3dTb );
4352   createTool( SMESHOp::OpVolume,                ctrl3dTb );
4353   createTool( SMESHOp::OpMaxElementLength3D,    ctrl3dTb );
4354   createTool( SMESHOp::OpBareBorderVolume,      ctrl3dTb );
4355   createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4356   createTool( SMESHOp::OpEqualVolume,           ctrl3dTb );
4357
4358   createTool( SMESHOp::OpNode,              addElemTb );
4359   createTool( SMESHOp::OpElem0D,            addElemTb );
4360   createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4361   createTool( SMESHOp::OpBall,              addElemTb );
4362   createTool( SMESHOp::OpEdge,              addElemTb );
4363   createTool( SMESHOp::OpTriangle,          addElemTb );
4364   createTool( SMESHOp::OpQuadrangle,        addElemTb );
4365   createTool( SMESHOp::OpPolygon,           addElemTb );
4366   createTool( SMESHOp::OpTetrahedron,       addElemTb );
4367   createTool( SMESHOp::OpHexahedron,        addElemTb );
4368   createTool( SMESHOp::OpPentahedron,       addElemTb );
4369   createTool( SMESHOp::OpPyramid,           addElemTb );
4370   createTool( SMESHOp::OpHexagonalPrism,    addElemTb );
4371   createTool( SMESHOp::OpPolyhedron,        addElemTb );
4372
4373   createTool( SMESHOp::OpQuadraticEdge,          addNonElemTb );
4374   createTool( SMESHOp::OpQuadraticTriangle,      addNonElemTb );
4375   createTool( SMESHOp::OpBiQuadraticTriangle,    addNonElemTb );
4376   createTool( SMESHOp::OpQuadraticQuadrangle,    addNonElemTb );
4377   createTool( SMESHOp::OpBiQuadraticQuadrangle,  addNonElemTb );
4378   createTool( SMESHOp::OpQuadraticPolygon,       addNonElemTb );
4379   createTool( SMESHOp::OpQuadraticTetrahedron,   addNonElemTb );
4380   createTool( SMESHOp::OpQuadraticPyramid,       addNonElemTb );
4381   createTool( SMESHOp::OpQuadraticPentahedron,   addNonElemTb );
4382   createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4383   createTool( SMESHOp::OpQuadraticHexahedron,    addNonElemTb );
4384   createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4385
4386   createTool( SMESHOp::OpRemoveNodes,       remTb );
4387   createTool( SMESHOp::OpRemoveElements,    remTb );
4388   createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4389   createTool( SMESHOp::OpClearMesh,         remTb );
4390
4391   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
4392   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4393
4394   createTool( SMESHOp::OpMergeNodes,     transformTb );
4395   createTool( SMESHOp::OpMergeElements,  transformTb );
4396   createTool( SMESHOp::OpTranslation,    transformTb );
4397   createTool( SMESHOp::OpRotation,       transformTb );
4398   createTool( SMESHOp::OpSymmetry,       transformTb );
4399   createTool( SMESHOp::OpScale,          transformTb );
4400   createTool( SMESHOp::OpOffset,         transformTb );
4401   createTool( SMESHOp::OpSewing,         transformTb );
4402   createTool( SMESHOp::OpDuplicateNodes, transformTb );
4403
4404   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4405   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4406   createTool( SMESHOp::OpExtrusion,              modifyTb );
4407   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
4408   createTool( SMESHOp::OpRevolution,             modifyTb );
4409   createTool( SMESHOp::OpOrientation,            modifyTb );
4410   createTool( SMESHOp::OpReorientFaces,          modifyTb );
4411   createTool( SMESHOp::OpMoveNode,               modifyTb );
4412   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
4413   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
4414   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
4415   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
4416   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
4417   createTool( SMESHOp::OpSplitBiQuadratic,       modifyTb );
4418   createTool( SMESHOp::OpSmoothing,              modifyTb );
4419   createTool( SMESHOp::OpPatternMapping,         modifyTb );
4420
4421   createTool( SMESHOp::OpMinimumDistance, measuremTb );
4422
4423   createTool( SMESHOp::OpUpdate, dispModeTb );
4424
4425   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4426   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4427
4428   myRules.clear();
4429   QString
4430     OB      = "'ObjectBrowser'",
4431     View    = "'" + SVTK_Viewer::Type() + "'",
4432     pat     = "'%1'",
4433     mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4434     group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4435     hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4436     algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4437     smesh   = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4438     elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4439     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4440     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4441     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4442     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4443     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4444     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4445     subMesh      = elems,
4446     mesh_part    = mesh + " " + subMesh + " " + group,
4447     mesh_group   = mesh + " " + group,
4448     mesh_submesh = mesh + " " + subMesh,
4449     hyp_alg      = hypo + " " + algo;
4450
4451   // popup for object browser
4452   QString
4453     isInvisible("not( isVisible )"),
4454     isEmpty("numberOfNodes = 0"),
4455     isNotEmpty("numberOfNodes <> 0"),
4456
4457     // has nodes, edges, etc in VISIBLE! actor
4458     hasNodes("(numberOfNodes > 0 ) && hasActor"),
4459     hasElems("(count( elemTypes ) > 0)"),
4460     hasDifferentElems("(count( elemTypes ) > 1)"),
4461     hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4462     hasBalls("({'BallElem'} in elemTypes)"),
4463     hasElems0d("({'Elem0d'} in elemTypes)"),
4464     hasEdges("({'Edge'} in elemTypes)"),
4465     hasFaces("({'Face'} in elemTypes)"),
4466     hasVolumes("({'Volume'} in elemTypes)"),
4467     hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4468
4469   createPopupItem( SMESHOp::OpFileInformation,   OB, mesh, "&& selcount=1 && isImported" );
4470   createPopupItem( SMESHOp::OpCreateSubMesh,     OB, mesh, "&& hasGeomReference");
4471   createPopupItem( SMESHOp::OpEditMesh,          OB, mesh, "&& selcount=1" );
4472   createPopupItem( SMESHOp::OpEditSubMesh,       OB, subMesh, "&& selcount=1 && hasGeomReference" );
4473   createPopupItem( SMESHOp::OpEditGroup,         OB, group );
4474   createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4475
4476   popupMgr()->insert( separator(), -1, 0 );
4477   createPopupItem( SMESHOp::OpCompute,           OB, mesh, "&& selcount=1 && isComputable" );
4478   createPopupItem( SMESHOp::OpComputeSubMesh,    OB, subMesh, "&& selcount=1 && isComputable" );
4479   createPopupItem( SMESHOp::OpPreCompute,        OB, mesh, "&& selcount=1 && isPreComputable" );
4480   createPopupItem( SMESHOp::OpEvaluate,          OB, mesh, "&& selcount=1 && isComputable" );
4481   createPopupItem( SMESHOp::OpMeshOrder,         OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4482   createPopupItem( SMESHOp::OpUpdate,            OB, mesh_part );
4483   createPopupItem( SMESHOp::OpMeshInformation,   OB, mesh_part );
4484   createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4485   createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4486   popupMgr()->insert( separator(), -1, 0 );
4487   createPopupItem( SMESHOp::OpCreateGroup,       OB, mesh, "&& selcount=1" );
4488   createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4489   createPopupItem( SMESHOp::OpConstructGroup,    OB, subMesh );
4490   popupMgr()->insert( separator(), -1, 0 );
4491   createPopupItem( SMESHOp::OpEditHypothesis,    OB, hypo, "&& isEditableHyp");
4492   createPopupItem( SMESHOp::OpUnassign,          OB, hyp_alg );
4493   popupMgr()->insert( separator(), -1, 0 );
4494   createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4495   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4496   popupMgr()->insert( separator(), -1, 0 );
4497   createPopupItem( SMESHOp::OpClearMesh,              OB, mesh );
4498   //popupMgr()->insert( separator(), -1, 0 );
4499
4500   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4501   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4502   QString only_one_2D        = only_one_non_empty + " && dim>1";
4503
4504   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4505   createPopupItem( SMESHOp::OpPopupExportMED,  OB, mesh_group, multiple_non_empty, anId );
4506   createPopupItem( SMESHOp::OpPopupExportUNV,  OB, mesh_group, only_one_non_empty, anId );
4507   createPopupItem( SMESHOp::OpPopupExportSTL,  OB, mesh_group, only_one_2D, anId );
4508 #ifdef WITH_CGNS
4509   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4510 #endif
4511   createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4512   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, only_one_non_empty, anId );
4513   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, only_one_non_empty, anId );
4514   createPopupItem( SMESHOp::OpDelete,          OB, mesh_part + " " + hyp_alg );
4515   createPopupItem( SMESHOp::OpDeleteGroup,     OB, group );
4516
4517   anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 );        // IMPORT submenu
4518   createPopupItem( SMESHOp::OpPopupImportMED,  OB, smesh, "", anId );
4519   createPopupItem( SMESHOp::OpPopupImportUNV,  OB, smesh, "", anId );
4520   createPopupItem( SMESHOp::OpPopupImportSTL,  OB, smesh, "", anId );
4521 #ifdef WITH_CGNS
4522   createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4523 #endif
4524   createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4525   createPopupItem( SMESHOp::OpPopupImportGMF,  OB, smesh, "", anId );
4526   createPopupItem( SMESHOp::OpPopupImportDAT,  OB, smesh, "", anId );
4527   popupMgr()->insert( separator(), -1, 0 );
4528
4529   // popup for viewer
4530   createPopupItem( SMESHOp::OpEditGroup,            View, group );
4531   createPopupItem( SMESHOp::OpAddElemGroupPopup,    View, elems, "&& guiState = 800" );
4532   createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4533
4534   popupMgr()->insert( separator(), -1, 0 );
4535   createPopupItem( SMESHOp::OpUpdate,             View, mesh_part );
4536   createPopupItem( SMESHOp::OpMeshInformation,    View, mesh_part );
4537   createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4538   createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4539   popupMgr()->insert( separator(), -1, 0 );
4540
4541   createPopupItem( SMESHOp::OpAutoColor,        OB + " " + View, mesh, "&& (not isAutoColor)" );
4542   createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4543   popupMgr()->insert( separator(), -1, 0 );
4544
4545   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4546   QString aType = QString( "%1type in {%2}" ).arg( lc );
4547   aType = aType.arg( mesh_part );
4548   QString aMeshInVTK = aClient + "&&" + aType;
4549
4550   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4551   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4552   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4553
4554   //-------------------------------------------------
4555   // Numbering
4556   //-------------------------------------------------
4557   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4558
4559   popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4560   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4561   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4562
4563   popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4564   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4565   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4566
4567   popupMgr()->insert( separator(), -1, -1 );
4568
4569   //-------------------------------------------------
4570   // Display Mode
4571   //-------------------------------------------------
4572   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4573
4574   popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4575   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4576   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4577
4578   popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4579   popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4580   popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4581
4582   popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4583   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4584   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4585
4586   popupMgr()->insert( separator(), anId, -1 );
4587
4588   popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4589   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4590   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4591
4592   //-------------------------------------------------
4593   // Display Entity
4594   //-------------------------------------------------
4595   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4596
4597   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4598
4599   popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4600   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4601   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4602
4603   popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4604   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4605   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4606
4607   popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4608   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4609   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4610
4611   popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4612   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4613   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4614
4615   popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4616   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4617   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4618
4619   popupMgr()->insert( separator(), anId, -1 );
4620
4621   popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4622   popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4623
4624   popupMgr()->insert( separator(), anId, -1 );
4625
4626   popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4627   popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4628
4629
4630   //-------------------------------------------------
4631   // Representation of the 2D Quadratic elements
4632   //-------------------------------------------------
4633   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4634   popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4635   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4636   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4637
4638   popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4639   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4640   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4641
4642   //-------------------------------------------------
4643   // Orientation of faces
4644   //-------------------------------------------------
4645   popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4646   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4647   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4648
4649   //-------------------------------------------------
4650   // Color / Size
4651   //-------------------------------------------------
4652   popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4653   popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4654
4655   //-------------------------------------------------
4656   // Transparency
4657   //-------------------------------------------------
4658   popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4659   popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4660
4661   //-------------------------------------------------
4662   // Controls
4663   //-------------------------------------------------
4664   QString
4665     aMeshInVtkHasNodes   = aMeshInVTK + "&&" + hasNodes,
4666     aMeshInVtkHasEdges   = aMeshInVTK + "&&" + hasEdges,
4667     aMeshInVtkHasFaces   = aMeshInVTK + "&&" + hasFaces,
4668     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4669
4670   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4671
4672   popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4673   popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4674
4675   popupMgr()->insert( separator(), anId, -1 );
4676
4677   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4678
4679   popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4680   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4681   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4682
4683   popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4684   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4685   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4686
4687   // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4688   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4689   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4690
4691   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4692
4693   popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4694   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4695   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4696
4697   popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4698   popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4699   popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4700
4701   popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4702   popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4703   popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4704   popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4705   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4706   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4707
4708   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4709
4710   popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4711   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4712   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4713
4714   popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4715   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4716                                        QtxPopupMgr::VisibleRule );
4717   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4718
4719   popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4720   popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4721   popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4722
4723   popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4724   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4725   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4726
4727   popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4728   popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4729   popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4730
4731   popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4732   popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4733   popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4734
4735   popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4736   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4737   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4738
4739   popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4740   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4741   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4742
4743   popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4744   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4745   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4746
4747   popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4748   popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4749   popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4750
4751   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4752   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4753   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4754
4755   popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4756   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4757   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4758
4759   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4760   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4761   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4762
4763   popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4764   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4765   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4766
4767   popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4768   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4769   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4770
4771   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4772
4773   popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D  ), aSubId, -1 );
4774   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4775   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4776
4777   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4778   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4779   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4780
4781   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4782   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4783   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4784
4785   popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4786   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4787   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4788
4789   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4790   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4791   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4792
4793   popupMgr()->insert ( action( SMESHOp::OpEqualVolume  ), aSubId, -1 );
4794   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4795   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4796
4797   popupMgr()->insert( separator(), anId, -1 );
4798
4799   popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4800   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4801   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4802   popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4803   popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4804
4805   popupMgr()->insert( separator(), anId, -1 );
4806
4807   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4808
4809   popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4810   popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4811
4812   popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4813   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4814   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4815
4816 #ifndef DISABLE_PLOT2DVIEWER
4817   popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4818   popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4819 #endif
4820
4821   //-------------------------------------------------
4822   // Show / Hide
4823   //-------------------------------------------------
4824   popupMgr()->insert( separator(), -1, -1 );
4825   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4826     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4827   popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4828   popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4829
4830   popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4831   popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4832
4833   popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4834   popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4835
4836   popupMgr()->insert( separator(), -1, -1 );
4837
4838   //-------------------------------------------------
4839   // Clipping
4840   //-------------------------------------------------
4841   popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4842   popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4843
4844   popupMgr()->insert( separator(), -1, -1 );
4845
4846   popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4847   popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4848   popupMgr()->insert( separator(), -1, -1 );
4849
4850   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4851            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4852
4853   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4854            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4855 }
4856
4857 //================================================================================
4858 /*!
4859  * \brief Return true if SMESH or GEOM objects are selected.
4860  * Is called form LightApp_Module::activateModule() which clear selection if
4861  * not isSelectionCompatible()
4862  */
4863 //================================================================================
4864
4865 bool SMESHGUI::isSelectionCompatible()
4866 {
4867   bool isCompatible = true;
4868   SALOME_ListIO selected;
4869   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4870     Sel->selectedObjects( selected );
4871
4872   SALOME_ListIteratorOfListIO It( selected );
4873   for ( ; isCompatible && It.More(); It.Next())
4874     isCompatible =
4875       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4876       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4877
4878   return isCompatible;
4879 }
4880
4881
4882 bool SMESHGUI::reusableOperation( const int id )
4883 {
4884   // compute, evaluate and precompute are not reusable operations
4885   return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4886 }
4887
4888 bool SMESHGUI::activateModule( SUIT_Study* study )
4889 {
4890   bool res = SalomeApp_Module::activateModule( study );
4891
4892   setMenuShown( true );
4893   setToolShown( true );
4894
4895   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4896   PyGILState_STATE gstate = PyGILState_Ensure();
4897   PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4898   if ( !pluginsmanager ) {
4899     PyErr_Print();
4900   }
4901   else {
4902     PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4903     if ( !result )
4904       PyErr_Print();
4905     Py_XDECREF(result);
4906   }
4907   PyGILState_Release(gstate);
4908   // end of SMESH plugins loading
4909
4910   // Reset actions accelerator keys
4911   action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4912
4913   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4914   GetSMESHGen()->UpdateStudy();
4915
4916   // get all view currently opened in the study and connect their signals  to
4917   // the corresponding slots of the class.
4918   SUIT_Desktop* aDesk = study->application()->desktop();
4919   if ( aDesk ) {
4920     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4921     SUIT_ViewWindow* wnd;
4922     foreach ( wnd, wndList )
4923       connectView( wnd );
4924   }
4925
4926   Py_XDECREF(pluginsmanager);
4927   return res;
4928 }
4929
4930 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4931 {
4932   setMenuShown( false );
4933   setToolShown( false );
4934
4935   EmitSignalCloseAllDialogs();
4936
4937   // Unset actions accelerator keys
4938   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4939
4940   return SalomeApp_Module::deactivateModule( study );
4941 }
4942
4943 void SMESHGUI::studyClosed( SUIT_Study* s )
4944 {
4945   if( !s )
4946     return;
4947   SMESH::RemoveVisuData();
4948   SalomeApp_Module::studyClosed( s );
4949 }
4950
4951 void SMESHGUI::OnGUIEvent()
4952 {
4953   const QObject* obj = sender();
4954   if ( !obj || !obj->inherits( "QAction" ) )
4955     return;
4956   int id = actionId((QAction*)obj);
4957   if ( id != -1 )
4958     OnGUIEvent( id );
4959 }
4960
4961 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4962 {
4963   if ( CORBA::is_nil( myComponentSMESH ) )
4964   {
4965     SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4966     return aGUI.myComponentSMESH;
4967   }
4968   return myComponentSMESH;
4969 }
4970
4971 QString SMESHGUI::engineIOR() const
4972 {
4973   CORBA::ORB_var anORB = getApp()->orb();
4974   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4975   return QString( anIOR.in() );
4976 }
4977
4978 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4979 {
4980   SalomeApp_Module::contextMenuPopup( client, menu, title );
4981   SALOME_ListIO lst;
4982   selectionMgr()->selectedObjects( lst );
4983   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4984     Handle(SALOME_InteractiveObject) io = lst.First();
4985     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4986     _PTR(Study) study = appStudy->studyDS();
4987     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4988     if ( obj ) {
4989       QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4990       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4991           aName.remove( (aName.length() - 1), 1 );
4992       title = aName;
4993     }
4994   }
4995 }
4996
4997 LightApp_Selection* SMESHGUI::createSelection() const
4998 {
4999   return new SMESHGUI_Selection();
5000 }
5001
5002 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5003 {
5004   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5005   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5006 #ifndef DISABLE_PYCONSOLE
5007   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5008 #endif
5009 }
5010
5011 void SMESHGUI::viewManagers( QStringList& list ) const
5012 {
5013   list.append( SVTK_Viewer::Type() );
5014 }
5015
5016 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5017 {
5018   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5019     SMESH::UpdateSelectionProp( this );
5020
5021     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5022     for(int i = 0; i < aViews.count() ; i++){
5023       SUIT_ViewWindow *sf = aViews[i];
5024       connectView( sf );
5025     }
5026     EmitSignalActivatedViewManager();
5027   }
5028 }
5029
5030 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5031 {
5032   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5033     myClippingPlaneInfoMap.erase( theViewManager );
5034 }
5035
5036 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5037 {
5038   theActor->AddObserver( SMESH::DeleteActorEvent,
5039                          myEventCallbackCommand.GetPointer(),
5040                          myPriority );
5041 }
5042
5043 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5044                               unsigned long theEvent,
5045                               void* theClientData,
5046                               void* theCallData )
5047 {
5048   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5049     if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5050       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5051         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5052         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5053         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5054           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5055           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5056           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5057             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5058             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5059             SMESH::TActorList::iterator anIter3 = anActorList.begin();
5060             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5061               if( anActor == *anIter3 ) {
5062                 anActorList.erase( anIter3 );
5063                 break;
5064               }
5065             }
5066           }
5067         }
5068       }
5069     }
5070   }
5071 }
5072
5073 void SMESHGUI::createPreferences()
5074 {
5075   // General tab ------------------------------------------------------------------------
5076   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5077
5078   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5079   setPreferenceProperty( autoUpdate, "columns", 2 );
5080   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5081   setPreferenceProperty( lim, "min",  0 );
5082   setPreferenceProperty( lim, "max",  100000000 );
5083   setPreferenceProperty( lim, "step", 1000 );
5084   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5085   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5086
5087   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5088   setPreferenceProperty( dispgroup, "columns", 2 );
5089
5090   addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5091
5092   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5093   QStringList modes;
5094   modes.append( tr("MEN_WIRE") );
5095   modes.append( tr("MEN_SHADE") );
5096   modes.append( tr("MEN_NODES") );
5097   modes.append( tr("MEN_SHRINK") );
5098   QList<QVariant> indices;
5099   indices.append( 0 );
5100   indices.append( 1 );
5101   indices.append( 2 );
5102   indices.append( 3 );
5103   setPreferenceProperty( dispmode, "strings", modes );
5104   setPreferenceProperty( dispmode, "indexes", indices );
5105
5106   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5107   setPreferenceProperty( arcgroup, "columns", 2 );
5108   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5109   QStringList quadraticModes;
5110   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5111   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5112   indices.clear();
5113   indices.append( 0 );
5114   indices.append( 1 );
5115   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5116   setPreferenceProperty( quadraticmode, "indexes", indices );
5117
5118   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5119                               "SMESH", "max_angle" );
5120   setPreferenceProperty( maxAngle, "min", 1 );
5121   setPreferenceProperty( maxAngle, "max", 90 );
5122
5123   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5124   setPreferenceProperty( qaGroup, "columns", 2 );
5125   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5126   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5127   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5128   setPreferenceProperty( prec, "min", 0 );
5129   setPreferenceProperty( prec, "max", 100 );
5130   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5131   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5132   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5133   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5134   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5135
5136   /*
5137   int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5138   setPreferenceProperty( cinc, "min", 0 );
5139   setPreferenceProperty( cinc, "max", 5 );
5140   */
5141
5142   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5143   setPreferenceProperty( exportgroup, "columns", 2 );
5144   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5145   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5146   int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5147   setPreferenceProperty( zTol, "precision", 10 );
5148   setPreferenceProperty( zTol, "min", 0.0000000001 );
5149   setPreferenceProperty( zTol, "max", 1000000.0 );
5150   setPreferenceProperty( zTol, "step", 1. );
5151   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5152
5153   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5154   setPreferenceProperty( computeGroup, "columns", 2 );
5155   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5156   modes.clear();
5157   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5158   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5159   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5160   indices.clear();
5161   indices.append( 0 );
5162   indices.append( 1 );
5163   indices.append( 2 );
5164   setPreferenceProperty( notifyMode, "strings", modes );
5165   setPreferenceProperty( notifyMode, "indexes", indices );
5166
5167   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5168   setPreferenceProperty( infoGroup, "columns", 2 );
5169   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5170   modes.clear();
5171   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5172   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5173   indices.clear();
5174   indices.append( 0 );
5175   indices.append( 1 );
5176   setPreferenceProperty( elemInfo, "strings", modes );
5177   setPreferenceProperty( elemInfo, "indexes", indices );
5178   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5179   setPreferenceProperty( nodesLim, "min", 0 );
5180   setPreferenceProperty( nodesLim, "max", 10000000 );
5181   setPreferenceProperty( nodesLim, "step", 10000 );
5182   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5183   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5184   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5185   setPreferenceProperty( ctrlLim, "min", 0 );
5186   setPreferenceProperty( ctrlLim, "max", 10000000 );
5187   setPreferenceProperty( ctrlLim, "step", 1000 );
5188   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5189   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5190   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5191   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5192   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5193
5194   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5195   setPreferenceProperty( segGroup, "columns", 2 );
5196   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5197                               "SMESH", "segmentation" );
5198   setPreferenceProperty( segLen, "min", 1 );
5199   setPreferenceProperty( segLen, "max", 10000000 );
5200   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5201                              "SMESH", "nb_segments_per_edge" );
5202   setPreferenceProperty( nbSeg, "min", 1 );
5203   setPreferenceProperty( nbSeg, "max", 10000000 );
5204
5205   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5206   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5207                  "SMESH", "forget_mesh_on_hyp_modif" );
5208
5209
5210   // Quantities with individual precision settings
5211   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5212   setPreferenceProperty( precGroup, "columns", 2 );
5213
5214   const int nbQuantities = 6;
5215   int precs[nbQuantities], ii = 0;
5216   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5217                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5218   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5219                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5220   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5221                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5222   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5223                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5224   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5225                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5226   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5227                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5228
5229   // Set property for precision value for spinboxes
5230   for ( ii = 0; ii < nbQuantities; ii++ ){
5231     setPreferenceProperty( precs[ii], "min", -14 );
5232     setPreferenceProperty( precs[ii], "max", 14 );
5233     setPreferenceProperty( precs[ii], "precision", 2 );
5234   }
5235
5236   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5237   setPreferenceProperty( previewGroup, "columns", 2 );
5238   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5239   setPreferenceProperty( chunkSize, "min",  1 );
5240   setPreferenceProperty( chunkSize, "max",  1000 );
5241   setPreferenceProperty( chunkSize, "step", 50 );
5242
5243   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5244   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5245
5246   // Mesh tab ------------------------------------------------------------------------
5247   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5248   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5249   setPreferenceProperty( nodeGroup, "columns", 3 );
5250
5251   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5252
5253   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5254
5255   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5256   QList<QVariant> aMarkerTypeIndicesList;
5257   QList<QVariant> aMarkerTypeIconsList;
5258   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5259     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5260     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5261     aMarkerTypeIndicesList << i;
5262     aMarkerTypeIconsList << pixmap;
5263   }
5264   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5265   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5266
5267   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5268
5269   QList<QVariant> aMarkerScaleIndicesList;
5270   QStringList     aMarkerScaleValuesList;
5271   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5272     aMarkerScaleIndicesList << i;
5273     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5274     aMarkerScaleValuesList  << QString::number( i );
5275   }
5276   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5277   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5278
5279   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5280   //setPreferenceProperty( elemGroup, "columns", 2 );
5281
5282   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5283   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5284   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5285   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5286   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5287   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5288   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5289   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5290   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5291
5292
5293   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5294   setPreferenceProperty( grpGroup, "columns", 2 );
5295
5296   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5297   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5298
5299   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5300                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5301   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5302                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5303   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5304                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5305   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5306                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5307   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5308                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5309   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5310                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5311   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5312                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5313
5314   setPreferenceProperty( size0d, "min", 1 );
5315   setPreferenceProperty( size0d, "max", 10 );
5316
5317  // setPreferenceProperty( ballSize, "min", 1 );
5318  // setPreferenceProperty( ballSize, "max", 10 );
5319
5320   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5321   setPreferenceProperty( ballDiameter, "max", 1e9 );
5322   setPreferenceProperty( ballDiameter, "step", 0.1 );
5323
5324   setPreferenceProperty( ballScale, "min", 1e-2 );
5325   setPreferenceProperty( ballScale, "max", 1e7 );
5326   setPreferenceProperty( ballScale, "step", 0.5 );
5327
5328   setPreferenceProperty( elemW, "min", 1 );
5329   setPreferenceProperty( elemW, "max", 5 );
5330
5331   setPreferenceProperty( outW, "min", 1 );
5332   setPreferenceProperty( outW, "max", 5 );
5333
5334   setPreferenceProperty( shrink, "min", 0 );
5335   setPreferenceProperty( shrink, "max", 100 );
5336
5337   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5338   setPreferenceProperty( numGroup, "columns", 2 );
5339
5340   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5341   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5342
5343   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5344   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5345
5346   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5347   setPreferenceProperty( orientGroup, "columns", 1 );
5348
5349   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5350   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5351
5352   setPreferenceProperty( orientScale, "min", 0.05 );
5353   setPreferenceProperty( orientScale, "max", 0.5 );
5354   setPreferenceProperty( orientScale, "step", 0.05 );
5355
5356   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5357
5358   // Selection tab ------------------------------------------------------------------------
5359   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5360
5361   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5362   setPreferenceProperty( selGroup, "columns", 2 );
5363
5364   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5365   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5366
5367   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5368   setPreferenceProperty( preGroup, "columns", 2 );
5369
5370   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5371
5372   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5373   setPreferenceProperty( precSelGroup, "columns", 2 );
5374
5375   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5376   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5377   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5378
5379   int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5380   setPreferenceProperty( sinc, "min", 0 );
5381   setPreferenceProperty( sinc, "max", 5 );
5382
5383   // Scalar Bar tab ------------------------------------------------------------------------
5384   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5385   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5386   setPreferenceProperty( fontGr, "columns", 2 );
5387
5388   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5389   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5390
5391   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5392   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5393
5394   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5395   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5396
5397   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5398   setPreferenceProperty( numcol, "min", 2 );
5399   setPreferenceProperty( numcol, "max", 256 );
5400
5401   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5402   setPreferenceProperty( numlab, "min", 2 );
5403   setPreferenceProperty( numlab, "max", 65 );
5404
5405   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5406   setPreferenceProperty( orientGr, "columns", 2 );
5407   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5408   QStringList orients;
5409   orients.append( tr( "SMESH_VERTICAL" ) );
5410   orients.append( tr( "SMESH_HORIZONTAL" ) );
5411   indices.clear(); indices.append( 0 ); indices.append( 1 );
5412   setPreferenceProperty( orient, "strings", orients );
5413   setPreferenceProperty( orient, "indexes", indices );
5414
5415   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5416   setPreferenceProperty( posVSizeGr, "columns", 2 );
5417   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5418   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5419   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5420   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5421   setPreferenceProperty( xv, "step", 0.1 );
5422   setPreferenceProperty( xv, "min", 0.0 );
5423   setPreferenceProperty( xv, "max", 1.0 );
5424   setPreferenceProperty( yv, "step", 0.1 );
5425   setPreferenceProperty( yv, "min", 0.0 );
5426   setPreferenceProperty( yv, "max", 1.0 );
5427   setPreferenceProperty( wv, "step", 0.1 );
5428   setPreferenceProperty( wv, "min", 0.0 );
5429   setPreferenceProperty( wv, "max", 1.0 );
5430   setPreferenceProperty( hv, "min", 0.0 );
5431   setPreferenceProperty( hv, "max", 1.0 );
5432   setPreferenceProperty( hv, "step", 0.1 );
5433
5434   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5435   setPreferenceProperty( posHSizeGr, "columns", 2 );
5436   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5437   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5438   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5439   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5440   setPreferenceProperty( xv, "min", 0.0 );
5441   setPreferenceProperty( xv, "max", 1.0 );
5442   setPreferenceProperty( xv, "step", 0.1 );
5443   setPreferenceProperty( xh, "min", 0.0 );
5444   setPreferenceProperty( xh, "max", 1.0 );
5445   setPreferenceProperty( xh, "step", 0.1 );
5446   setPreferenceProperty( yh, "min", 0.0 );
5447   setPreferenceProperty( yh, "max", 1.0 );
5448   setPreferenceProperty( yh, "step", 0.1 );
5449   setPreferenceProperty( wh, "min", 0.0 );
5450   setPreferenceProperty( wh, "max", 1.0 );
5451   setPreferenceProperty( wh, "step", 0.1 );
5452   setPreferenceProperty( hh, "min", 0.0 );
5453   setPreferenceProperty( hh, "max", 1.0 );
5454   setPreferenceProperty( hh, "step", 0.1 );
5455
5456   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5457   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5458   setPreferenceProperty( distributionGr, "columns", 3 );
5459   QStringList types;
5460   types.append( tr( "SMESH_MONOCOLOR" ) );
5461   types.append( tr( "SMESH_MULTICOLOR" ) );
5462   indices.clear(); indices.append( 0 ); indices.append( 1 );
5463   setPreferenceProperty( coloringType, "strings", types );
5464   setPreferenceProperty( coloringType, "indexes", indices );
5465   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5466
5467 }
5468
5469 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5470 {
5471   if ( sect=="SMESH" ) {
5472     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5473     float aTol = 1.00000009999999;
5474     std::string aWarning;
5475     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5476
5477     if ( name== "selection_object_color" ||
5478          name=="selection_element_color" ||
5479          name==        "highlight_color" ||
5480          name=="selection_precision_node"    ||
5481          name=="selection_precision_element" ||
5482          name=="selection_precision_object"   ||
5483          name=="selection_increment")
5484     {
5485       SMESH::UpdateSelectionProp( this );
5486     }
5487     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5488     {
5489       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5490       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5491       if ( sbX1+sbW > aTol ) {
5492         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5493         sbX1 = 0.01;
5494         sbW  = 0.08;
5495         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5496         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5497       }
5498     }
5499     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5500     {
5501       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5502       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5503       if ( sbY1 + sbH > aTol ) {
5504         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5505         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5506         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5507       }
5508     }
5509     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5510     {
5511       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5512       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5513       if ( sbX1 + sbW > aTol ) {
5514         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5515         sbX1=0.1;
5516         sbW =0.08;
5517         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5518         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5519       }
5520     }
5521     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5522     {
5523       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5524       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5525       if ( sbY1 + sbH > aTol ) {
5526         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5527         sbY1=0.01;
5528         sbH =0.08;
5529         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5530         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5531       }
5532     }
5533     else if ( name == "segmentation" )
5534     {
5535       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5536       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5537     }
5538     else if ( name == "nb_segments_per_edge" )
5539     {
5540       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5541       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5542     }
5543     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5544     {
5545       QString val = aResourceMgr->stringValue( "SMESH", name );
5546       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5547     }
5548     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5549     {
5550       SMESH::UpdateFontProp( this );
5551     }
5552     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5553     {
5554       SMESH::UpdateFontProp( this );
5555     }
5556
5557     if ( aWarning.size() != 0 ) {
5558       aWarning += "The default values are applied instead.";
5559       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5560                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5561                                QObject::tr(aWarning.c_str()));
5562     }
5563   }
5564 }
5565
5566 //================================================================================
5567 /*!
5568  * \brief Update something in accordance with update flags
5569   * \param theFlags - update flags
5570 *
5571 * Update viewer or/and object browser etc. in accordance with update flags ( see
5572 * LightApp_UpdateFlags enumeration ).
5573 */
5574 //================================================================================
5575 void SMESHGUI::update( const int flags )
5576 {
5577   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5578     SMESH::UpdateView();
5579   else
5580     SalomeApp_Module::update( flags );
5581 }
5582
5583 //================================================================================
5584 /*!
5585  * \brief Set default selection mode
5586 *
5587 * SLOT called when operation committed. Sets default selection mode
5588 */
5589 //================================================================================
5590 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5591 {
5592   SVTK_ViewWindow* vtkWnd =
5593     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5594   if ( vtkWnd )
5595     vtkWnd->SetSelectionMode( ActorSelection );
5596 }
5597
5598 //================================================================================
5599 /*!
5600  * \brief Set default selection mode
5601 *
5602 * SLOT called when operation aborted. Sets default selection mode
5603 */
5604 //================================================================================
5605 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5606 {
5607   SVTK_ViewWindow* vtkWnd =
5608     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5609   if ( vtkWnd )
5610     vtkWnd->SetSelectionMode( ActorSelection );
5611 }
5612
5613 //================================================================================
5614 /*!
5615  * \brief Creates operation with given identifier
5616   * \param id - identifier of operation to be started
5617   * \return Pointer on created operation or NULL if operation is not created
5618 *
5619 * Virtual method redefined from the base class creates operation with given id.
5620 * It is called called automatically from startOperation method of base class.
5621 */
5622 //================================================================================
5623 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5624 {
5625   LightApp_Operation* op = 0;
5626   // to do : create operation here
5627   switch( id )
5628   {
5629     case SMESHOp::OpSplitBiQuadratic:
5630       op = new SMESHGUI_SplitBiQuadOp();
5631     break;
5632     case SMESHOp::OpConvertMeshToQuadratic:
5633       op = new SMESHGUI_ConvToQuadOp();
5634     break;
5635     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5636       op = new SMESHGUI_Make2DFrom3DOp();
5637     break;
5638     case SMESHOp::OpReorientFaces:
5639       op = new SMESHGUI_ReorientFacesOp();
5640       break;
5641     case SMESHOp::OpCreateMesh:
5642       op = new SMESHGUI_MeshOp( true, true );
5643     break;
5644     case SMESHOp::OpCreateSubMesh:
5645       op = new SMESHGUI_MeshOp( true, false );
5646     break;
5647     case SMESHOp::OpEditMeshOrSubMesh:
5648     case SMESHOp::OpEditMesh:
5649     case SMESHOp::OpEditSubMesh:
5650       op = new SMESHGUI_MeshOp( false );
5651     break;
5652     case SMESHOp::OpCompute:
5653     case SMESHOp::OpComputeSubMesh:
5654       op = new SMESHGUI_ComputeOp();
5655     break;
5656     case SMESHOp::OpPreCompute:
5657       op = new SMESHGUI_PrecomputeOp();
5658     break;
5659     case SMESHOp::OpEvaluate:
5660       op = new SMESHGUI_EvaluateOp();
5661     break;
5662     case SMESHOp::OpMeshOrder:
5663       op = new SMESHGUI_MeshOrderOp();
5664     break;
5665     case SMESHOp::OpCreateGeometryGroup:
5666       op = new SMESHGUI_GroupOnShapeOp();
5667       break;
5668     case SMESHOp::OpFindElementByPoint:
5669       op = new SMESHGUI_FindElemByPointOp();
5670       break;
5671     case SMESHOp::OpMoveNode: // Make mesh pass through point
5672       op = new SMESHGUI_MakeNodeAtPointOp();
5673       break;
5674     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5675       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5676       break;
5677     default:
5678     break;
5679   }
5680
5681   if( !op )
5682     op = SalomeApp_Module::createOperation( id );
5683   return op;
5684 }
5685
5686 //================================================================================
5687 /*!
5688  * \brief Stops current operations and starts a given one
5689   * \param id - The id of the operation to start
5690  */
5691 //================================================================================
5692
5693 void SMESHGUI::switchToOperation(int id)
5694 {
5695   activeStudy()->abortAllOperations();
5696   startOperation( id );
5697 }
5698
5699 LightApp_Displayer* SMESHGUI::displayer()
5700 {
5701   if( !myDisplayer )
5702     myDisplayer = new SMESHGUI_Displayer( getApp() );
5703   return myDisplayer;
5704 }
5705
5706 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5707 {
5708   int aHue = -1;
5709   int aTolerance = 64;
5710   int anIterations = 0;
5711   int aPeriod = 5;
5712
5713   while( 1 )
5714   {
5715     anIterations++;
5716     if( anIterations % aPeriod == 0 )
5717     {
5718       aTolerance /= 2;
5719       if( aTolerance < 1 )
5720         break;
5721     }
5722
5723     aHue = (int)( 360.0 * rand() / RAND_MAX );
5724
5725     bool ok = true;
5726     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5727     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5728     for( ; it != itEnd; ++it )
5729     {
5730       SALOMEDS::Color anAutoColor = *it;
5731       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5732
5733       int h, s, v;
5734       aQColor.getHsv( &h, &s, &v );
5735       if( abs( h - aHue ) < aTolerance )
5736       {
5737         ok = false;
5738         break;
5739       }
5740     }
5741
5742     if( ok )
5743       break;
5744   }
5745
5746   QColor aColor;
5747   aColor.setHsv( aHue, 255, 255 );
5748
5749   SALOMEDS::Color aSColor;
5750   aSColor.R = aColor.redF();
5751   aSColor.G = aColor.greenF();
5752   aSColor.B = aColor.blueF();
5753
5754   return aSColor;
5755 }
5756
5757 const char* gSeparator = "_"; // character used to separate parameter names
5758 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5759 const char* gPathSep   = "|"; // character used to separate paths
5760
5761 /*!
5762  * \brief Store visual parameters
5763  *
5764  * This method is called just before the study document is saved.
5765  * Store visual parameters in AttributeParameter attribute(s)
5766  */
5767 void SMESHGUI::storeVisualParameters (int savePoint)
5768 {
5769   // localizing
5770   Kernel_Utils::Localizer loc;
5771
5772   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5773   if (!appStudy || !appStudy->studyDS())
5774     return;
5775   _PTR(Study) studyDS = appStudy->studyDS();
5776
5777   // componentName is used for encoding of entries when storing them in IParameters
5778   std::string componentName = myComponentSMESH->ComponentDataType();
5779   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5780   //if (!aSComponent) return;
5781
5782   // IParameters
5783   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5784                                                              componentName.c_str(),
5785                                                              savePoint);
5786   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5787
5788   // store custom markers
5789   if( !myMarkerMap.empty() )
5790   {
5791     VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5792     for( ; anIter != myMarkerMap.end(); anIter++ )
5793     {
5794       int anId = anIter->first;
5795       VTK::MarkerData aMarkerData = anIter->second;
5796       std::string aMarkerFileName = aMarkerData.first;
5797       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5798       if( aMarkerTexture.size() < 3 )
5799         continue; // should contain at least width, height and the first value
5800
5801       QString aPropertyName( "texture" );
5802       aPropertyName += gSeparator;
5803       aPropertyName += QString::number( anId );
5804
5805       QString aPropertyValue = aMarkerFileName.c_str();
5806       aPropertyValue += gPathSep;
5807
5808       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5809       ushort aWidth = *aTextureIter++;
5810       ushort aHeight = *aTextureIter++;
5811       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5812       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5813       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5814         aPropertyValue += QString::number( *aTextureIter );
5815
5816       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5817     }
5818   }
5819
5820   // viewers counters are used for storing view_numbers in IParameters
5821   int vtkViewers = 0;
5822
5823   // main cycle to store parameters of displayed objects
5824   QList<SUIT_ViewManager*> lst;
5825   QList<SUIT_ViewManager*>::Iterator it;
5826   getApp()->viewManagers(lst);
5827   for (it = lst.begin(); it != lst.end(); it++)
5828   {
5829     SUIT_ViewManager* vman = *it;
5830     QString vType = vman->getType();
5831
5832     // saving VTK actors properties
5833     if (vType == SVTK_Viewer::Type())
5834     {
5835       // store the clipping planes attached to the view manager
5836       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5837       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5838       if( anIter != myClippingPlaneInfoMap.end() )
5839         aClippingPlaneInfoList = anIter->second;
5840
5841       if( !aClippingPlaneInfoList.empty() ) {
5842         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5843         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5844         {
5845           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5846           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5847
5848           QString aPropertyName( "ClippingPlane" );
5849           aPropertyName += gSeparator;
5850           aPropertyName += QString::number( vtkViewers );
5851           aPropertyName += gSeparator;
5852           aPropertyName += QString::number( anId );
5853
5854           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5855           aPropertyValue += gDigitsSep;
5856           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5857           aPropertyValue += gDigitsSep;
5858           if ( aPlane->PlaneMode == SMESH::Absolute ) {
5859             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5860             aPropertyValue += gDigitsSep;
5861             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5862             aPropertyValue += gDigitsSep;
5863             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5864             aPropertyValue += gDigitsSep;
5865             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5866             aPropertyValue += gDigitsSep;
5867             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5868             aPropertyValue += gDigitsSep;
5869             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5870             aPropertyValue += gDigitsSep;
5871             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5872           }
5873           else if ( aPlane->PlaneMode == SMESH::Relative ) {
5874             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5875             aPropertyValue += gDigitsSep;
5876             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5877             aPropertyValue += gDigitsSep;
5878             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5879             aPropertyValue += gDigitsSep;
5880             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5881           }
5882
5883           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5884         }
5885       }
5886
5887       QVector<SUIT_ViewWindow*> views = vman->getViews();
5888       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5889       {
5890         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5891         {
5892           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5893           vtkActorCollection* allActors = aCopy.GetActors();
5894           allActors->InitTraversal();
5895           while (vtkActor* actor = allActors->GetNextActor())
5896           {
5897             if (actor->GetVisibility()) // store only visible actors
5898             {
5899               SMESH_Actor* aSmeshActor = 0;
5900               if (actor->IsA("SMESH_Actor"))
5901                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5902               if (aSmeshActor && aSmeshActor->hasIO())
5903               {
5904                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5905                 if (io->hasEntry())
5906                 {
5907                   // entry is "encoded" = it does NOT contain component address,
5908                   // since it is a subject to change on next component loading
5909                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5910
5911                   std::string param, vtkParam = vType.toLatin1().data();
5912                   vtkParam += gSeparator;
5913                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5914                   vtkParam += gSeparator;
5915
5916                   // Visibility
5917                   param = vtkParam + "Visibility";
5918                   ip->setParameter(entry, param, "On");
5919
5920                   // Representation
5921                   param = vtkParam + "Representation";
5922                   ip->setParameter(entry, param, QString::number
5923                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5924
5925                   // IsShrunk
5926                   param = vtkParam + "IsShrunk";
5927                   ip->setParameter(entry, param, QString::number
5928                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5929
5930                   // Displayed entities
5931                   unsigned int aMode = aSmeshActor->GetEntityMode();
5932                   bool isE  = aMode & SMESH_Actor::eEdges;
5933                   bool isF  = aMode & SMESH_Actor::eFaces;
5934                   bool isV  = aMode & SMESH_Actor::eVolumes;
5935                   bool is0d = aMode & SMESH_Actor::e0DElements;
5936                   bool isB  = aMode & SMESH_Actor::eBallElem;
5937
5938                   QString modeStr ("e");
5939                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5940                   modeStr += gDigitsSep; modeStr += "f";
5941                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5942                   modeStr += gDigitsSep; modeStr += "v";
5943                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5944                   modeStr += gDigitsSep; modeStr += "0d";
5945                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5946                   modeStr += gDigitsSep; modeStr += "b";
5947                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5948
5949                   param = vtkParam + "Entities";
5950                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5951
5952                   // Colors
5953                   double r, g, b;
5954                   int delta;
5955
5956                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5957                   QStringList colorStr;
5958                   colorStr << "surface";
5959                   colorStr << QString::number(r);
5960                   colorStr << QString::number(g);
5961                   colorStr << QString::number(b);
5962
5963                   colorStr << "backsurface";
5964                   colorStr << QString::number(delta);
5965
5966                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5967                   colorStr << "volume";
5968                   colorStr << QString::number(r);
5969                   colorStr << QString::number(g);
5970                   colorStr << QString::number(b);
5971                   colorStr << QString::number(delta);
5972
5973                   aSmeshActor->GetEdgeColor(r, g, b);
5974                   colorStr << "edge";
5975                   colorStr << QString::number(r);
5976                   colorStr << QString::number(g);
5977                   colorStr << QString::number(b);
5978
5979                   aSmeshActor->GetNodeColor(r, g, b);
5980                   colorStr << "node";
5981                   colorStr << QString::number(r);
5982                   colorStr << QString::number(g);
5983                   colorStr << QString::number(b);
5984
5985                   aSmeshActor->GetOutlineColor(r, g, b);
5986                   colorStr << "outline";
5987                   colorStr << QString::number(r);
5988                   colorStr << QString::number(g);
5989                   colorStr << QString::number(b);
5990
5991                   aSmeshActor->Get0DColor(r, g, b);
5992                   colorStr << "elem0d";
5993                   colorStr << QString::number(r);
5994                   colorStr << QString::number(g);
5995                   colorStr << QString::number(b);
5996
5997                   aSmeshActor->GetBallColor(r, g, b);
5998                   colorStr << "ball";
5999                   colorStr << QString::number(r);
6000                   colorStr << QString::number(g);
6001                   colorStr << QString::number(b);
6002
6003                   aSmeshActor->GetFacesOrientationColor(r, g, b);
6004                   colorStr << "orientation";
6005                   colorStr << QString::number(r);
6006                   colorStr << QString::number(g);
6007                   colorStr << QString::number(b);
6008
6009                   param = vtkParam + "Colors";
6010                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6011
6012                   // Sizes
6013                   QStringList sizeStr;
6014                   sizeStr << "line";
6015                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6016                   sizeStr << "outline";
6017                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6018                   sizeStr << "elem0d";
6019                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6020                   sizeStr << "ball";
6021                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6022                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6023                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6024                   sizeStr << "shrink";
6025                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6026                   sizeStr << "orientation";
6027                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6028                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6029
6030                   param = vtkParam + "Sizes";
6031                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6032
6033                   // Point marker
6034                   QString markerStr;
6035
6036                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6037                   if( aMarkerType == VTK::MT_USER ) {
6038                     markerStr += "custom";
6039                     markerStr += gDigitsSep;
6040                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6041                   }
6042                   else {
6043                     markerStr += "std";
6044                     markerStr += gDigitsSep;
6045                     markerStr += QString::number( (int)aMarkerType );
6046                     markerStr += gDigitsSep;
6047                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6048                   }
6049
6050                   param = vtkParam + "PointMarker";
6051                   ip->setParameter(entry, param, markerStr.toLatin1().data());
6052
6053                   // Opacity
6054                   param = vtkParam + "Opacity";
6055                   ip->setParameter(entry, param,
6056                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6057
6058                   // Clipping
6059                   param = vtkParam + "ClippingPlane";
6060                   int aPlaneId = 0;
6061                   if( !aClippingPlaneInfoList.empty() ) {
6062                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6063                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6064                     {
6065                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6066                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6067                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
6068                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6069                         if( aSmeshActor == *anIter2 ) {
6070                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6071                                             QString::number( anId ).toLatin1().constData() );
6072                           break;
6073                         }
6074                       }
6075                     }
6076                   }
6077                   if( aPlaneId == 0 )
6078                     ip->setParameter( entry, param, "Off" );
6079                 } // if (io->hasEntry())
6080               } // SMESH_Actor && hasIO
6081             } // isVisible
6082           } // while.. actors traversal
6083         } // if (vtkView)
6084       } // for (views)
6085       vtkViewers++;
6086     } // if (SVTK view model)
6087   } // for (viewManagers)
6088 }
6089
6090 // data structures for clipping planes processing
6091 typedef struct {
6092   int Id;
6093   int Mode;
6094   bool isOpenGLClipping;
6095   vtkIdType RelativeOrientation;
6096   double Distance;
6097   double Angle[2];
6098   int AbsoluteOrientation;
6099   double X, Y, Z, Dx, Dy, Dz;
6100 } TPlaneData;
6101 typedef std::list<TPlaneData>         TPlaneDataList;
6102 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6103
6104 typedef std::list<vtkActor*>          TActorList;
6105 typedef struct {
6106   int PlaneId;
6107   TActorList ActorList;
6108   SUIT_ViewManager* ViewManager;
6109 } TPlaneInfo;
6110 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6111 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6112
6113 /*!
6114  * \brief Restore visual parameters
6115  *
6116  * This method is called after the study document is opened.
6117  * Restore visual parameters from AttributeParameter attribute(s)
6118  */
6119 void SMESHGUI::restoreVisualParameters (int savePoint)
6120 {
6121   // localizing
6122   Kernel_Utils::Localizer loc;
6123
6124   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6125   if (!appStudy || !appStudy->studyDS())
6126     return;
6127   _PTR(Study) studyDS = appStudy->studyDS();
6128
6129   // componentName is used for encoding of entries when storing them in IParameters
6130   std::string componentName = myComponentSMESH->ComponentDataType();
6131   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6132   //if (!aSComponent) return;
6133
6134   // IParameters
6135   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6136                                                              componentName.c_str(),
6137                                                              savePoint);
6138   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6139
6140   // restore custom markers and map of clipping planes
6141   TPlaneDataMap aPlaneDataMap;
6142
6143   std::vector<std::string> properties = ip->getProperties();
6144   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6145   {
6146     std::string property = *propIt;
6147     QString aPropertyName( property.c_str() );
6148     QString aPropertyValue( ip->getProperty( property ).c_str() );
6149
6150     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6151     if( aPropertyNameList.isEmpty() )
6152       continue;
6153
6154     QString aPropertyType = aPropertyNameList[0];
6155     if( aPropertyType == "texture" )
6156     {
6157       if( aPropertyNameList.size() != 2 )
6158         continue;
6159
6160       bool ok = false;
6161       int anId = aPropertyNameList[1].toInt( &ok );
6162       if( !ok || anId < 1 )
6163         continue;
6164
6165       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6166       if( aPropertyValueList.size() != 2 )
6167         continue;
6168
6169       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6170       QString aMarkerTextureString = aPropertyValueList[1];
6171       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6172       if( aMarkerTextureStringList.size() != 3 )
6173         continue;
6174
6175       ok = false;
6176       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6177       if( !ok )
6178         continue;
6179
6180       ok = false;
6181       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6182       if( !ok )
6183         continue;
6184
6185       VTK::MarkerTexture aMarkerTexture;
6186       aMarkerTexture.push_back( aWidth );
6187       aMarkerTexture.push_back( aHeight );
6188
6189       QString aMarkerTextureData = aMarkerTextureStringList[2];
6190       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6191       {
6192         QChar aChar = aMarkerTextureData.at( i );
6193         if( aChar.isDigit() )
6194           aMarkerTexture.push_back( aChar.digitValue() );
6195       }
6196
6197       myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6198     }
6199     else if( aPropertyType == "ClippingPlane" )
6200     {
6201       if( aPropertyNameList.size() != 3 )
6202         continue;
6203
6204       bool ok = false;
6205       int aViewId = aPropertyNameList[1].toInt( &ok );
6206       if( !ok || aViewId < 0 )
6207         continue;
6208
6209       ok = false;
6210       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6211       if( !ok || aClippingPlaneId < 0 )
6212         continue;
6213
6214       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6215       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6216         continue;
6217
6218       TPlaneData aPlaneData;
6219       aPlaneData.AbsoluteOrientation = false;
6220       aPlaneData.RelativeOrientation = 0;
6221       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6222       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6223       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6224
6225       aPlaneData.Id = aClippingPlaneId;
6226
6227       ok = false;
6228       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6229       if( !ok )
6230         continue;
6231
6232       ok = false;
6233       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6234       if( !ok )
6235         continue;
6236
6237       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6238       {
6239         ok = false;
6240         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6241         if( !ok )
6242           continue;
6243
6244         ok = false;
6245         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6246         if( !ok )
6247           continue;
6248
6249         ok = false;
6250         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6251         if( !ok )
6252           continue;
6253
6254         ok = false;
6255         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6256         if( !ok )
6257           continue;
6258
6259         ok = false;
6260         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6261         if( !ok )
6262           continue;
6263
6264         ok = false;
6265         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6266         if( !ok )
6267           continue;
6268
6269         ok = false;
6270         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6271         if( !ok )
6272           continue;
6273       }
6274       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6275         ok = false;
6276         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6277         if( !ok )
6278           continue;
6279
6280         ok = false;
6281         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6282         if( !ok )
6283           continue;
6284
6285         ok = false;
6286         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6287         if( !ok )
6288           continue;
6289
6290         ok = false;
6291         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6292         if( !ok )
6293           continue;
6294       }
6295
6296       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6297       aPlaneDataList.push_back( aPlaneData );
6298     }
6299   }
6300
6301   TPlaneInfoMap aPlaneInfoMap;
6302
6303   std::vector<std::string> entries = ip->getEntries();
6304
6305   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6306   {
6307     // entry is a normal entry - it should be "decoded" (setting base address of component)
6308     QString entry (ip->decodeEntry(*entIt).c_str());
6309
6310     // Check that the entry corresponds to a real object in the Study
6311     // as the object may be deleted or modified after the visual state is saved.
6312     _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6313     if (!so) continue; //Skip the not existent entry
6314
6315     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6316     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6317
6318     std::vector<std::string>::iterator namesIt = paramNames.begin();
6319     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6320
6321     // actors are stored in a map after displaying of them for
6322     // quicker access in the future: map < viewID to actor >
6323     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6324
6325     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6326     {
6327       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6328       // '_' is used as separator and should not be used in viewer type or parameter names.
6329       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6330       if (lst.size() != 3)
6331         continue;
6332
6333       QString viewerTypStr = lst[0];
6334       QString viewIndexStr = lst[1];
6335       QString paramNameStr = lst[2];
6336
6337       bool ok;
6338       int viewIndex = viewIndexStr.toUInt(&ok);
6339       if (!ok) // bad conversion of view index to integer
6340         continue;
6341
6342       // viewers
6343       if (viewerTypStr == SVTK_Viewer::Type())
6344       {
6345         SMESH_Actor* aSmeshActor = 0;
6346         if (vtkActors.IsBound(viewIndex))
6347           aSmeshActor = vtkActors.Find(viewIndex);
6348
6349         QList<SUIT_ViewManager*> lst;
6350         getApp()->viewManagers(viewerTypStr, lst);
6351
6352         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6353         SUIT_ViewManager* vman = NULL;
6354         if (viewIndex >= 0 && viewIndex < lst.count())
6355           vman = lst.at(viewIndex);
6356
6357         if (paramNameStr == "Visibility")
6358         {
6359           if (!aSmeshActor && displayer() && vman)
6360           {
6361             SUIT_ViewModel* vmodel = vman->getViewModel();
6362             // SVTK view model can be casted to SALOME_View
6363             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6364
6365             // store displayed actor in a temporary map for quicker
6366             // access later when restoring other parameters
6367             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6368             vtkRenderer* Renderer = vtkView->getRenderer();
6369             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6370             vtkActorCollection* theActors = aCopy.GetActors();
6371             theActors->InitTraversal();
6372             bool isFound = false;
6373             vtkActor *ac = theActors->GetNextActor();
6374             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6375               if (ac->IsA("SMESH_Actor")) {
6376                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6377                 if (aGeomAc->hasIO()) {
6378                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6379                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6380                     isFound = true;
6381                     vtkActors.Bind(viewIndex, aGeomAc);
6382                   }
6383                 }
6384               }
6385             }
6386           }
6387         } // if (paramNameStr == "Visibility")
6388         else
6389         {
6390           // the rest properties "work" with SMESH_Actor
6391           if (aSmeshActor)
6392           {
6393             QString val ((*valuesIt).c_str());
6394
6395             // Representation
6396             if (paramNameStr == "Representation") {
6397               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6398             }
6399             // IsShrunk
6400             else if (paramNameStr == "IsShrunk") {
6401               if (val.toInt()) {
6402                 if (!aSmeshActor->IsShrunk())
6403                   aSmeshActor->SetShrink();
6404               }
6405               else {
6406                 if (aSmeshActor->IsShrunk())
6407                   aSmeshActor->UnShrink();
6408               }
6409             }
6410             // Displayed entities
6411             else if (paramNameStr == "Entities") {
6412               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6413               int aEntityMode = SMESH_Actor::eAllEntity;
6414               for ( int i = 0; i < mode.count(); i+=2 ) {
6415                 if ( i < mode.count()-1 ) {
6416                   QString type = mode[i];
6417                   bool val = mode[i+1].toInt();
6418                   if      ( type == "e" && !val )
6419                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6420                   else if ( type == "f" && !val )
6421                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6422                   else if ( type == "v" && !val )
6423                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6424                   else if ( type == "0d" && !val )
6425                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6426                   else if ( type == "b" && !val )
6427                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6428                 }
6429               }
6430               aSmeshActor->SetEntityMode( aEntityMode );
6431             }
6432             // Colors
6433             else if (paramNameStr == "Colors") {
6434               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6435               QColor nodeColor;
6436               QColor edgeColor;
6437               QColor faceColor;
6438               QColor volumeColor;
6439               QColor elem0dColor;
6440               QColor ballColor;
6441               QColor outlineColor;
6442               QColor orientationColor;
6443               int deltaF;
6444               int deltaV;
6445               QColor c;
6446               double r, g, b;
6447               bool bOk;
6448               // below lines are required to get default values for delta coefficients
6449               // of backface color for faces and color of reversed volumes
6450               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6451               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6452               for ( int i = 0; i < colors.count(); i++ ) {
6453                 QString type = colors[i];
6454                 if ( type == "surface" ) {
6455                   // face color is set by 3 values r:g:b, where
6456                   // - r,g,b - is rgb color components
6457                   if ( i+1 >= colors.count() ) break;                  // format error
6458                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6459                   if ( i+2 >= colors.count() ) break;                  // format error
6460                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6461                   if ( i+3 >= colors.count() ) break;                  // format error
6462                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6463                   faceColor.setRgbF( r, g, b );
6464                   i += 3;
6465                 }
6466                 else if ( type == "backsurface" ) {
6467                   // backface color can be defined in several ways
6468                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6469                   // - in latest versions, it is set as delta coefficient
6470                   bool rgbOk = false, deltaOk;
6471                   if ( i+1 >= colors.count() ) break;                  // format error
6472                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6473                   int delta = colors[i+1].toInt( &deltaOk );
6474                   i++;                                 // shift index
6475                   if ( i+1 < colors.count() )          // index is shifted to 1
6476                     g = colors[i+1].toDouble( &rgbOk );
6477                   if ( rgbOk ) i++;                    // shift index
6478                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6479                     b = colors[i+1].toDouble( &rgbOk );
6480                   if ( rgbOk ) i++;
6481                   // - as currently there's no way to set directly backsurface color as it was before,
6482                   // we ignore old dump where r,g,b triple was set
6483                   // - also we check that delta parameter is set properly
6484                   if ( !rgbOk && deltaOk )
6485                     deltaF = delta;
6486                 }
6487                 else if ( type == "volume" ) {
6488                   // volume color is set by 4 values r:g:b:delta, where
6489                   // - r,g,b - is a normal volume rgb color components
6490                   // - delta - is a reversed volume color delta coefficient
6491                   if ( i+1 >= colors.count() ) break;                  // format error
6492                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6493                   if ( i+2 >= colors.count() ) break;                  // format error
6494                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6495                   if ( i+3 >= colors.count() ) break;                  // format error
6496                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6497                   if ( i+4 >= colors.count() ) break;                  // format error
6498                   int delta = colors[i+4].toInt( &bOk );
6499                   if ( !bOk ) break;                                   // format error
6500                   volumeColor.setRgbF( r, g, b );
6501                   deltaV = delta;
6502                   i += 4;
6503                 }
6504                 else if ( type == "edge" ) {
6505                   // edge color is set by 3 values r:g:b, where
6506                   // - r,g,b - is rgb color components
6507                   if ( i+1 >= colors.count() ) break;                  // format error
6508                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6509                   if ( i+2 >= colors.count() ) break;                  // format error
6510                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6511                   if ( i+3 >= colors.count() ) break;                  // format error
6512                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6513                   edgeColor.setRgbF( r, g, b );
6514                   i += 3;
6515                 }
6516                 else if ( type == "node" ) {
6517                   // node color is set by 3 values r:g:b, where
6518                   // - r,g,b - is rgb color components
6519                   if ( i+1 >= colors.count() ) break;                  // format error
6520                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6521                   if ( i+2 >= colors.count() ) break;                  // format error
6522                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6523                   if ( i+3 >= colors.count() ) break;                  // format error
6524                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6525                   nodeColor.setRgbF( r, g, b );
6526                   i += 3;
6527                 }
6528                 else if ( type == "elem0d" ) {
6529                   // 0d element color is set by 3 values r:g:b, where
6530                   // - r,g,b - is rgb color components
6531                   if ( i+1 >= colors.count() ) break;                  // format error
6532                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6533                   if ( i+2 >= colors.count() ) break;                  // format error
6534                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6535                   if ( i+3 >= colors.count() ) break;                  // format error
6536                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6537                   elem0dColor.setRgbF( r, g, b );
6538                   i += 3;
6539                 }
6540                 else if ( type == "ball" ) {
6541                   // ball color is set by 3 values r:g:b, where
6542                   // - r,g,b - is rgb color components
6543                   if ( i+1 >= colors.count() ) break;                  // format error
6544                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6545                   if ( i+2 >= colors.count() ) break;                  // format error
6546                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6547                   if ( i+3 >= colors.count() ) break;                  // format error
6548                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6549                   ballColor.setRgbF( r, g, b );
6550                   i += 3;
6551                 }
6552                 else if ( type == "outline" ) {
6553                   // outline color is set by 3 values r:g:b, where
6554                   // - r,g,b - is rgb color components
6555                   if ( i+1 >= colors.count() ) break;                  // format error
6556                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6557                   if ( i+2 >= colors.count() ) break;                  // format error
6558                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6559                   if ( i+3 >= colors.count() ) break;                  // format error
6560                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6561                   outlineColor.setRgbF( r, g, b );
6562                   i += 3;
6563                 }
6564                 else if ( type == "orientation" ) {
6565                   // orientation color is set by 3 values r:g:b, where
6566                   // - r,g,b - is rgb color components
6567                   if ( i+1 >= colors.count() ) break;                  // format error
6568                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6569                   if ( i+2 >= colors.count() ) break;                  // format error
6570                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6571                   if ( i+3 >= colors.count() ) break;                  // format error
6572                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6573                   orientationColor.setRgbF( r, g, b );
6574                   i += 3;
6575                 }
6576               }
6577               // node color
6578               if ( nodeColor.isValid() )
6579                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6580               // edge color
6581               if ( edgeColor.isValid() )
6582                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6583               // face color
6584               if ( faceColor.isValid() )
6585                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6586               // volume color
6587               if ( volumeColor.isValid() )
6588                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6589               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6590                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6591               // 0d element color
6592               if ( elem0dColor.isValid() )
6593                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6594               // ball color
6595               if ( ballColor.isValid() )
6596                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6597               // outline color
6598               if ( outlineColor.isValid() )
6599                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6600               // orientation color
6601               if ( orientationColor.isValid() )
6602                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6603             }
6604             // Sizes
6605             else if (paramNameStr == "Sizes") {
6606               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6607               bool bOk;
6608               int lineWidth = -1;
6609               int outlineWidth = -1;
6610               int elem0dSize = -1;
6611               //int ballSize = -1;
6612               double ballDiameter = -1.0;
6613               double ballScale = -1.0;
6614               double shrinkSize = -1;
6615               double orientationSize = -1;
6616               bool orientation3d = false;
6617               for ( int i = 0; i < sizes.count(); i++ ) {
6618                 QString type = sizes[i];
6619                 if ( type == "line" ) {
6620                   // line (wireframe) width is given as single integer value
6621                   if ( i+1 >= sizes.count() ) break;                    // format error
6622                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6623                   lineWidth = v;
6624                   i++;
6625                 }
6626                 if ( type == "outline" ) {
6627                   // outline width is given as single integer value
6628                   if ( i+1 >= sizes.count() ) break;                    // format error
6629                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6630                   outlineWidth = v;
6631                   i++;
6632                 }
6633                 else if ( type == "elem0d" ) {
6634                   // 0d element size is given as single integer value
6635                   if ( i+1 >= sizes.count() ) break;                    // format error
6636                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6637                   elem0dSize = v;
6638                   i++;
6639                 }
6640                 else if ( type == "ball" ) {
6641                   // balls are specified by two values: size:scale, where
6642                   // - size - is a integer value specifying size
6643                   // - scale - is a double value specifying scale factor
6644                   if ( i+1 >= sizes.count() ) break;                       // format error
6645                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6646                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6647                   if ( i+2 >= sizes.count() ) break;                       // format error
6648                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6649                   //ballSize = v1;
6650                   ballDiameter = v1;
6651                   ballScale = v2;
6652                   i += 2;
6653                 }
6654                 else if ( type == "shrink" ) {
6655                   // shrink factor is given as single floating point value
6656                   if ( i+1 >= sizes.count() ) break;                          // format error
6657                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6658                   shrinkSize = v;
6659                   i++;
6660                 }
6661                 else if ( type == "orientation" ) {
6662                   // orientation vectors are specified by two values size:3d, where
6663                   // - size - is a floating point value specifying scale factor
6664                   // - 3d - is a boolean
6665                   if ( i+1 >= sizes.count() ) break;                          // format error
6666                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6667                   if ( i+2 >= sizes.count() ) break;                          // format error
6668                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6669                   orientationSize = v1;
6670                   orientation3d = (bool)v2;
6671                   i += 2;
6672                 }
6673               }
6674               // line (wireframe) width
6675               if ( lineWidth > 0 )
6676                 aSmeshActor->SetLineWidth( lineWidth );
6677               // outline width
6678               if ( outlineWidth > 0 )
6679                 aSmeshActor->SetOutlineWidth( outlineWidth );
6680               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6681                 aSmeshActor->SetOutlineWidth( lineWidth );
6682               // 0d element size
6683               if ( elem0dSize > 0 )
6684                 aSmeshActor->Set0DSize( elem0dSize );
6685               // ball size
6686               /*if ( ballSize > 0 )
6687                 aSmeshActor->SetBallSize( ballSize );*/
6688               // ball diameter
6689               if ( ballDiameter > 0 )
6690                 aSmeshActor->SetBallSize( ballDiameter );
6691               // ball scale
6692               if ( ballScale > 0.0 )
6693                 aSmeshActor->SetBallScale( ballScale );
6694               // shrink factor
6695               if ( shrinkSize > 0 )
6696                 aSmeshActor->SetShrinkFactor( shrinkSize );
6697               // orientation vectors
6698               if ( orientationSize > 0 ) {
6699                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6700                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6701               }
6702             }
6703             // Point marker
6704             else if (paramNameStr == "PointMarker") {
6705               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6706               if( data.count() >= 2 ) {
6707                 bool ok = false;
6708                 int aParam1 = data[1].toInt( &ok );
6709                 if( ok ) {
6710                   if( data[0] == "std" && data.count() == 3 ) {
6711                     int aParam2 = data[2].toInt( &ok );
6712                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6713                   }
6714                   else if( data[0] == "custom" ) {
6715                     VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6716                     if( markerIt != myMarkerMap.end() ) {
6717                       VTK::MarkerData aMarkerData = markerIt->second;
6718                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6719                     }
6720                   }
6721                 }
6722               }
6723             }
6724             // Opacity
6725             else if (paramNameStr == "Opacity") {
6726               aSmeshActor->SetOpacity(val.toFloat());
6727             }
6728             // Clipping
6729             else if (paramNameStr.startsWith("ClippingPlane")) {
6730               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6731               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6732               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6733               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6734               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6735               // new format - val looks like "Off" or "0" (plane id)
6736               // (note: in new format "Off" value is used only for consistency,
6737               //  so it is processed together with values in old format)
6738               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6739               if( anIsOldFormat ) {
6740                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6741                   aSmeshActor->RemoveAllClippingPlanes();
6742                 if (val != "Off") {
6743                   QList<SUIT_ViewManager*> lst;
6744                   getApp()->viewManagers(viewerTypStr, lst);
6745                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6746                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6747                     SUIT_ViewManager* vman = lst.at(viewIndex);
6748                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6749
6750                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6751
6752                     SMESH::TActorList anActorList;
6753                     anActorList.push_back( aSmeshActor );
6754                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6755                     aPlane->myViewWindow = vtkView;
6756                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6757                     aPlane->PlaneMode = aMode;
6758                     bool isOpenGLClipping = ( bool )vals[1].toInt();
6759                     aPlane->IsOpenGLClipping = isOpenGLClipping;
6760                     if ( aMode == SMESH::Absolute ) {
6761                       aPlane->myAbsoluteOrientation = vals[2].toInt();
6762                       aPlane->X = vals[3].toFloat();
6763                       aPlane->Y = vals[4].toFloat();
6764                       aPlane->Z = vals[5].toFloat();
6765                       aPlane->Dx = vals[6].toFloat();
6766                       aPlane->Dy = vals[7].toFloat();
6767                       aPlane->Dz = vals[8].toFloat();
6768                     }
6769                     else if ( aMode == SMESH::Relative ) {
6770                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6771                       aPlane->myDistance = vals[3].toFloat();
6772                       aPlane->myAngle[0] = vals[4].toFloat();
6773                       aPlane->myAngle[1] = vals[5].toFloat();
6774                     }
6775
6776                     if( aPlane ) {
6777                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6778                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6779                         aClippingPlaneInfo.Plane = aPlane;
6780                         aClippingPlaneInfo.ActorList = anActorList;
6781                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6782                       }
6783                     }
6784                   }
6785                 }
6786               }
6787               else {
6788                 bool ok = false;
6789                 int aPlaneId = val.toInt( &ok );
6790                 if( ok && aPlaneId >= 0 ) {
6791                   bool anIsDefinedPlane = false;
6792                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6793                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6794                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6795                     TPlaneInfo& aPlaneInfo = *anIter;
6796                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6797                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6798                       anIsDefinedPlane = true;
6799                       break;
6800                     }
6801                   }
6802                   if( !anIsDefinedPlane ) {
6803                     TPlaneInfo aPlaneInfo;
6804                     aPlaneInfo.PlaneId = aPlaneId;
6805                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6806                     aPlaneInfo.ViewManager = vman;
6807
6808                     // to make the list sorted by plane id
6809                     anIter = aPlaneInfoList.begin();
6810                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6811                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6812                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6813                         break;
6814                     }
6815                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6816                   }
6817                 }
6818               }
6819             }
6820           } // if (aSmeshActor)
6821         } // other parameters than Visibility
6822       }
6823     } // for names/parameters iterator
6824   } // for entries iterator
6825
6826   // take into account planes with empty list of actors referred to them
6827   QList<SUIT_ViewManager*> aVMList;
6828   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6829
6830   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6831   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6832     int aViewId = aPlaneDataIter->first;
6833     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6834       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6835
6836       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6837
6838       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6839       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6840       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6841         const TPlaneData& aPlaneData = *anIter2;
6842         int aPlaneId = aPlaneData.Id;
6843
6844         bool anIsFound = false;
6845         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6846         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6847           const TPlaneInfo& aPlaneInfo = *anIter3;
6848           if( aPlaneInfo.PlaneId == aPlaneId ) {
6849             anIsFound = true;
6850             break;
6851           }
6852         }
6853
6854         if( !anIsFound ) {
6855           TPlaneInfo aPlaneInfo; // ActorList field is empty
6856           aPlaneInfo.PlaneId = aPlaneId;
6857           aPlaneInfo.ViewManager = aViewManager;
6858
6859           // to make the list sorted by plane id
6860           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6861           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6862             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6863             if( aPlaneInfoRef.PlaneId > aPlaneId )
6864               break;
6865           }
6866           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6867         }
6868       }
6869     }
6870   }
6871
6872   // add clipping planes to actors according to the restored parameters
6873   // and update the clipping plane map
6874   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6875   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6876     int aViewId = anIter1->first;
6877     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6878
6879     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6880     if( anIter2 == aPlaneDataMap.end() )
6881       continue;
6882     const TPlaneDataList& aPlaneDataList = anIter2->second;
6883
6884     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6885     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6886       const TPlaneInfo& aPlaneInfo = *anIter3;
6887       int aPlaneId = aPlaneInfo.PlaneId;
6888       const TActorList& anActorList = aPlaneInfo.ActorList;
6889       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6890       if( !aViewManager )
6891         continue;
6892
6893       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6894       if( !aViewWindow )
6895         continue;
6896
6897       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6898
6899       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6900       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6901         const TPlaneData& aPlaneData = *anIter4;
6902         if( aPlaneData.Id == aPlaneId ) {
6903           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6904           aPlane->myViewWindow = aViewWindow;
6905           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6906           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6907           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6908             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6909             aPlane->X = aPlaneData.X;
6910             aPlane->Y = aPlaneData.Y;
6911             aPlane->Z = aPlaneData.Z;
6912             aPlane->Dx = aPlaneData.Dx;
6913             aPlane->Dy = aPlaneData.Dy;
6914             aPlane->Dz = aPlaneData.Dz;
6915           }
6916           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6917             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6918             aPlane->myDistance = aPlaneData.Distance;
6919             aPlane->myAngle[0] = aPlaneData.Angle[0];
6920             aPlane->myAngle[1] = aPlaneData.Angle[1];
6921           }
6922           if( aPlane ) {
6923             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6924               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6925               aClippingPlaneInfo.Plane = aPlane;
6926               aClippingPlaneInfo.ActorList = anActorList;
6927               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6928             }
6929           }
6930           break;
6931         }
6932       }
6933
6934     }
6935   }
6936
6937
6938   // update all VTK views
6939   QList<SUIT_ViewManager*> lst;
6940   getApp()->viewManagers(lst);
6941   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6942     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6943     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6944       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6945       // set OpenGL clipping planes
6946       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6947       vtkActorCollection* anAllActors = aCopy.GetActors();
6948       anAllActors->InitTraversal();
6949       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6950         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6951           anActor->SetOpenGLClippingPlane();
6952
6953       vtkView->getRenderer()->ResetCameraClippingRange();
6954       vtkView->Repaint();
6955     }
6956   }
6957 }
6958
6959 /*!
6960   \brief Adds preferences for dfont of VTK viewer
6961   \param label label
6962   \param pIf group identifier
6963   \param param parameter
6964   \return identifier of preferences
6965 */
6966 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6967 {
6968   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6969
6970   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6971
6972   QStringList fam;
6973   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6974   fam.append( tr( "SMESH_FONT_COURIER" ) );
6975   fam.append( tr( "SMESH_FONT_TIMES" ) );
6976
6977   setPreferenceProperty( tfont, "fonts", fam );
6978
6979   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6980   if ( needSize ) f = f | QtxFontEdit::Size;
6981   setPreferenceProperty( tfont, "features", f );
6982
6983   return tfont;
6984 }
6985
6986 /*!
6987   \brief Actions after hypothesis edition
6988   Updates object browser after hypothesis edition
6989 */
6990 void SMESHGUI::onHypothesisEdit( int result )
6991 {
6992   if( result == 1 )
6993     SMESHGUI::Modified();
6994   updateObjBrowser( true );
6995 }
6996
6997 /*!
6998   \brief Actions after choosing menu of control modes
6999   Updates control mode actions according to current selection
7000 */
7001 void SMESHGUI::onUpdateControlActions()
7002 {
7003   SALOME_ListIO selected;
7004   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7005     aSel->selectedObjects( selected );
7006
7007   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7008   if ( selected.Extent() ) {
7009     if ( selected.First()->hasEntry() ) {
7010       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7011         aControl = anActor->GetControlMode();
7012         SALOME_ListIteratorOfListIO it(selected);
7013         for ( it.Next(); it.More(); it.Next() ) {
7014           Handle(SALOME_InteractiveObject) anIO = it.Value();
7015           if ( anIO->hasEntry() ) {
7016             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7017               if ( aControl != anActor->GetControlMode() ) {
7018                 aControl = SMESH_Actor::eNone;
7019                 break;
7020               }
7021             }
7022           }
7023         }
7024       }
7025     }
7026   }
7027
7028   int anAction = ActionToControl( aControl, true );
7029   if ( anAction)
7030     action( anAction )->setChecked( true );
7031   else {
7032     QMenu* send = (QMenu*)sender();
7033     QList<QAction*> actions = send->actions();
7034     for ( int i = 0; i < actions.size(); i++ )
7035       actions[i]->setChecked( false );
7036   }
7037 }
7038
7039
7040 /*!
7041   \brief Signal handler closing(SUIT_ViewWindow*) of a view
7042   \param pview view being closed
7043 */
7044 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7045 #ifndef DISABLE_PLOT2DVIEWER
7046   //Crear all Plot2d Viewers if need.
7047   SMESH::ClearPlot2Viewers(pview);
7048 #endif
7049   EmitSignalCloseView();
7050 }
7051
7052 void SMESHGUI::message( const QString& msg )
7053 {
7054   // dispatch message
7055   QStringList data = msg.split("/");
7056   if ( data.count() > 0 ) {
7057     if ( data.first() == "mesh_loading" ) {
7058       // get mesh entry
7059       QString entry = data.count() > 1 ? data[1] : QString();
7060       if ( entry.isEmpty() )
7061         return;
7062       // get study
7063       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7064       // get mesh name
7065       _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7066       QString name;
7067       if ( obj )
7068         name = SMESH::fromUtf8(obj->GetName());
7069       if ( name.isEmpty() )
7070         return;
7071
7072       if ( data.last() == "stop" )
7073         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7074       else
7075         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7076       QApplication::processEvents();
7077     }
7078   }
7079 }
7080
7081 /*!
7082   \brief Connects or disconnects signals about activating and cloning view on the module slots
7083   \param pview view which is connected/disconnected
7084 */
7085 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7086   if(!pview)
7087     return;
7088
7089   SUIT_ViewManager* viewMgr = pview->getViewManager();
7090   if ( viewMgr ) {
7091     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7092                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7093
7094     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7095              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7096   }
7097 }
7098
7099 /*!
7100   \brief Return \c true if object can be renamed
7101 */
7102 bool SMESHGUI::renameAllowed( const QString& entry) const {
7103   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7104   if( !anApp )
7105     return false;
7106
7107   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7108   if( !appStudy )
7109     return false;
7110
7111   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7112
7113   if(!obj)
7114     return false;
7115
7116   if(appStudy->isComponent(entry) || obj->isReference())
7117     return false;
7118
7119   // check type to prevent renaming of inappropriate objects
7120   int aType = SMESHGUI_Selection::type(qPrintable(entry));
7121   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7122       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7123       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7124       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7125       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7126     return true;
7127
7128   return false;
7129 }
7130
7131 /*!
7132   Rename object by entry.
7133   \param entry entry of the object
7134   \param name new name of the object
7135   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7136 */
7137 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7138
7139   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7140   if( !anApp )
7141     return false;
7142
7143   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7144
7145   if(!appStudy)
7146     return false;
7147
7148   _PTR(Study) aStudy = appStudy->studyDS();
7149
7150   if(!aStudy)
7151     return false;
7152
7153   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7154   if ( aLocked ) {
7155     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7156     return false;
7157   }
7158
7159
7160   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7161   _PTR(GenericAttribute) anAttr;
7162   _PTR(AttributeName) aName;
7163   if ( obj ) {
7164     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7165       aName = anAttr;
7166       // check type to prevent renaming of inappropriate objects
7167       int aType = SMESHGUI_Selection::type( qPrintable(entry));
7168       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7169           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7170           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7171           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7172           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7173         if ( !name.isEmpty() ) {
7174           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7175
7176           // update name of group object and its actor
7177           Handle(SALOME_InteractiveObject) IObject =
7178             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7179
7180           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7181           if( !aGroupObject->_is_nil() ) {
7182             aGroupObject->SetName( qUtf8Printable(name) );
7183             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7184               anActor->setName( qUtf8Printable(name) );
7185           }
7186           return true;
7187         }
7188       }
7189     }
7190   }
7191   return false;
7192 }
7193
7194 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7195 {
7196   static QList<QColor> colors;
7197
7198   if ( colors.isEmpty() ) {
7199
7200     for (int s = 0; s < 2 ; s++)
7201     {
7202       for (int v = 100; v >= 40; v = v - 20)
7203       {
7204         for (int h = 0; h < 359 ; h = h + 60)
7205         {
7206           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7207         }
7208       }
7209     }
7210   }
7211   static int currentColor = randomize( colors.size() );
7212
7213   SALOMEDS::Color color;
7214   color.R = (double)colors[currentColor].red()   / 255.0;
7215   color.G = (double)colors[currentColor].green() / 255.0;
7216   color.B = (double)colors[currentColor].blue()  / 255.0;
7217
7218   currentColor = (currentColor+1) % colors.count();
7219
7220   return color;
7221 }