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   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5090   QStringList modes;
5091   modes.append( tr("MEN_WIRE") );
5092   modes.append( tr("MEN_SHADE") );
5093   modes.append( tr("MEN_NODES") );
5094   modes.append( tr("MEN_SHRINK") );
5095   QList<QVariant> indices;
5096   indices.append( 0 );
5097   indices.append( 1 );
5098   indices.append( 2 );
5099   indices.append( 3 );
5100   setPreferenceProperty( dispmode, "strings", modes );
5101   setPreferenceProperty( dispmode, "indexes", indices );
5102
5103   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5104   setPreferenceProperty( arcgroup, "columns", 2 );
5105   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5106   QStringList quadraticModes;
5107   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5108   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5109   indices.clear();
5110   indices.append( 0 );
5111   indices.append( 1 );
5112   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5113   setPreferenceProperty( quadraticmode, "indexes", indices );
5114
5115   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5116                               "SMESH", "max_angle" );
5117   setPreferenceProperty( maxAngle, "min", 1 );
5118   setPreferenceProperty( maxAngle, "max", 90 );
5119
5120   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5121   setPreferenceProperty( qaGroup, "columns", 2 );
5122   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5123   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5124   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5125   setPreferenceProperty( prec, "min", 0 );
5126   setPreferenceProperty( prec, "max", 100 );
5127   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5128   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5129   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5130   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5131   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5132
5133   /*
5134   int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5135   setPreferenceProperty( cinc, "min", 0 );
5136   setPreferenceProperty( cinc, "max", 5 );
5137   */
5138
5139   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5140   setPreferenceProperty( exportgroup, "columns", 2 );
5141   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5142   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5143   int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5144   setPreferenceProperty( zTol, "precision", 10 );
5145   setPreferenceProperty( zTol, "min", 0.0000000001 );
5146   setPreferenceProperty( zTol, "max", 1000000.0 );
5147   setPreferenceProperty( zTol, "step", 1. );
5148   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5149
5150   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5151   setPreferenceProperty( computeGroup, "columns", 2 );
5152   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5153   modes.clear();
5154   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5155   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5156   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5157   indices.clear();
5158   indices.append( 0 );
5159   indices.append( 1 );
5160   indices.append( 2 );
5161   setPreferenceProperty( notifyMode, "strings", modes );
5162   setPreferenceProperty( notifyMode, "indexes", indices );
5163
5164   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5165   setPreferenceProperty( infoGroup, "columns", 2 );
5166   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5167   modes.clear();
5168   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5169   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5170   indices.clear();
5171   indices.append( 0 );
5172   indices.append( 1 );
5173   setPreferenceProperty( elemInfo, "strings", modes );
5174   setPreferenceProperty( elemInfo, "indexes", indices );
5175   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5176   setPreferenceProperty( nodesLim, "min", 0 );
5177   setPreferenceProperty( nodesLim, "max", 10000000 );
5178   setPreferenceProperty( nodesLim, "step", 10000 );
5179   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5180   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5181   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5182   setPreferenceProperty( ctrlLim, "min", 0 );
5183   setPreferenceProperty( ctrlLim, "max", 10000000 );
5184   setPreferenceProperty( ctrlLim, "step", 1000 );
5185   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5186   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5187   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5188   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5189   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5190
5191   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5192   setPreferenceProperty( segGroup, "columns", 2 );
5193   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5194                               "SMESH", "segmentation" );
5195   setPreferenceProperty( segLen, "min", 1 );
5196   setPreferenceProperty( segLen, "max", 10000000 );
5197   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5198                              "SMESH", "nb_segments_per_edge" );
5199   setPreferenceProperty( nbSeg, "min", 1 );
5200   setPreferenceProperty( nbSeg, "max", 10000000 );
5201
5202   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5203   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5204                  "SMESH", "forget_mesh_on_hyp_modif" );
5205
5206
5207   // Quantities with individual precision settings
5208   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5209   setPreferenceProperty( precGroup, "columns", 2 );
5210
5211   const int nbQuantities = 6;
5212   int precs[nbQuantities], ii = 0;
5213   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5214                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5215   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5216                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5217   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5218                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5219   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5220                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5221   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5222                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5223   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5224                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5225
5226   // Set property for precision value for spinboxes
5227   for ( ii = 0; ii < nbQuantities; ii++ ){
5228     setPreferenceProperty( precs[ii], "min", -14 );
5229     setPreferenceProperty( precs[ii], "max", 14 );
5230     setPreferenceProperty( precs[ii], "precision", 2 );
5231   }
5232
5233   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5234   setPreferenceProperty( previewGroup, "columns", 2 );
5235   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5236   setPreferenceProperty( chunkSize, "min",  1 );
5237   setPreferenceProperty( chunkSize, "max",  1000 );
5238   setPreferenceProperty( chunkSize, "step", 50 );
5239
5240   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5241   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5242
5243   // Mesh tab ------------------------------------------------------------------------
5244   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5245   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5246   setPreferenceProperty( nodeGroup, "columns", 3 );
5247
5248   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5249
5250   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5251
5252   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5253   QList<QVariant> aMarkerTypeIndicesList;
5254   QList<QVariant> aMarkerTypeIconsList;
5255   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5256     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5257     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5258     aMarkerTypeIndicesList << i;
5259     aMarkerTypeIconsList << pixmap;
5260   }
5261   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5262   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5263
5264   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5265
5266   QList<QVariant> aMarkerScaleIndicesList;
5267   QStringList     aMarkerScaleValuesList;
5268   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5269     aMarkerScaleIndicesList << i;
5270     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5271     aMarkerScaleValuesList  << QString::number( i );
5272   }
5273   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5274   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5275
5276   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5277   //setPreferenceProperty( elemGroup, "columns", 2 );
5278
5279   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5280   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5281   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5282   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5283   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5284   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5285   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5286   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5287   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5288
5289
5290   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5291   setPreferenceProperty( grpGroup, "columns", 2 );
5292
5293   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5294   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5295
5296   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5297                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5298   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5299                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5300   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5301                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5302   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5303                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5304   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5305                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5306   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5307                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5308   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5309                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5310
5311   setPreferenceProperty( size0d, "min", 1 );
5312   setPreferenceProperty( size0d, "max", 10 );
5313
5314  // setPreferenceProperty( ballSize, "min", 1 );
5315  // setPreferenceProperty( ballSize, "max", 10 );
5316
5317   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5318   setPreferenceProperty( ballDiameter, "max", 1e9 );
5319   setPreferenceProperty( ballDiameter, "step", 0.1 );
5320
5321   setPreferenceProperty( ballScale, "min", 1e-2 );
5322   setPreferenceProperty( ballScale, "max", 1e7 );
5323   setPreferenceProperty( ballScale, "step", 0.5 );
5324
5325   setPreferenceProperty( elemW, "min", 1 );
5326   setPreferenceProperty( elemW, "max", 5 );
5327
5328   setPreferenceProperty( outW, "min", 1 );
5329   setPreferenceProperty( outW, "max", 5 );
5330
5331   setPreferenceProperty( shrink, "min", 0 );
5332   setPreferenceProperty( shrink, "max", 100 );
5333
5334   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5335   setPreferenceProperty( numGroup, "columns", 2 );
5336
5337   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5338   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5339
5340   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5341   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5342
5343   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5344   setPreferenceProperty( orientGroup, "columns", 1 );
5345
5346   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5347   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5348
5349   setPreferenceProperty( orientScale, "min", 0.05 );
5350   setPreferenceProperty( orientScale, "max", 0.5 );
5351   setPreferenceProperty( orientScale, "step", 0.05 );
5352
5353   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5354
5355   // Selection tab ------------------------------------------------------------------------
5356   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5357
5358   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5359   setPreferenceProperty( selGroup, "columns", 2 );
5360
5361   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5362   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5363
5364   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5365   setPreferenceProperty( preGroup, "columns", 2 );
5366
5367   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5368
5369   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5370   setPreferenceProperty( precSelGroup, "columns", 2 );
5371
5372   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5373   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5374   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5375
5376   int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5377   setPreferenceProperty( sinc, "min", 0 );
5378   setPreferenceProperty( sinc, "max", 5 );
5379
5380   // Scalar Bar tab ------------------------------------------------------------------------
5381   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5382   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5383   setPreferenceProperty( fontGr, "columns", 2 );
5384
5385   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5386   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5387
5388   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5389   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5390
5391   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5392   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5393
5394   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5395   setPreferenceProperty( numcol, "min", 2 );
5396   setPreferenceProperty( numcol, "max", 256 );
5397
5398   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5399   setPreferenceProperty( numlab, "min", 2 );
5400   setPreferenceProperty( numlab, "max", 65 );
5401
5402   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5403   setPreferenceProperty( orientGr, "columns", 2 );
5404   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5405   QStringList orients;
5406   orients.append( tr( "SMESH_VERTICAL" ) );
5407   orients.append( tr( "SMESH_HORIZONTAL" ) );
5408   indices.clear(); indices.append( 0 ); indices.append( 1 );
5409   setPreferenceProperty( orient, "strings", orients );
5410   setPreferenceProperty( orient, "indexes", indices );
5411
5412   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5413   setPreferenceProperty( posVSizeGr, "columns", 2 );
5414   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5415   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5416   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5417   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5418   setPreferenceProperty( xv, "step", 0.1 );
5419   setPreferenceProperty( xv, "min", 0.0 );
5420   setPreferenceProperty( xv, "max", 1.0 );
5421   setPreferenceProperty( yv, "step", 0.1 );
5422   setPreferenceProperty( yv, "min", 0.0 );
5423   setPreferenceProperty( yv, "max", 1.0 );
5424   setPreferenceProperty( wv, "step", 0.1 );
5425   setPreferenceProperty( wv, "min", 0.0 );
5426   setPreferenceProperty( wv, "max", 1.0 );
5427   setPreferenceProperty( hv, "min", 0.0 );
5428   setPreferenceProperty( hv, "max", 1.0 );
5429   setPreferenceProperty( hv, "step", 0.1 );
5430
5431   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5432   setPreferenceProperty( posHSizeGr, "columns", 2 );
5433   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5434   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5435   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5436   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5437   setPreferenceProperty( xv, "min", 0.0 );
5438   setPreferenceProperty( xv, "max", 1.0 );
5439   setPreferenceProperty( xv, "step", 0.1 );
5440   setPreferenceProperty( xh, "min", 0.0 );
5441   setPreferenceProperty( xh, "max", 1.0 );
5442   setPreferenceProperty( xh, "step", 0.1 );
5443   setPreferenceProperty( yh, "min", 0.0 );
5444   setPreferenceProperty( yh, "max", 1.0 );
5445   setPreferenceProperty( yh, "step", 0.1 );
5446   setPreferenceProperty( wh, "min", 0.0 );
5447   setPreferenceProperty( wh, "max", 1.0 );
5448   setPreferenceProperty( wh, "step", 0.1 );
5449   setPreferenceProperty( hh, "min", 0.0 );
5450   setPreferenceProperty( hh, "max", 1.0 );
5451   setPreferenceProperty( hh, "step", 0.1 );
5452
5453   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5454   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5455   setPreferenceProperty( distributionGr, "columns", 3 );
5456   QStringList types;
5457   types.append( tr( "SMESH_MONOCOLOR" ) );
5458   types.append( tr( "SMESH_MULTICOLOR" ) );
5459   indices.clear(); indices.append( 0 ); indices.append( 1 );
5460   setPreferenceProperty( coloringType, "strings", types );
5461   setPreferenceProperty( coloringType, "indexes", indices );
5462   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5463
5464 }
5465
5466 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5467 {
5468   if ( sect=="SMESH" ) {
5469     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5470     float aTol = 1.00000009999999;
5471     std::string aWarning;
5472     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5473
5474     if ( name== "selection_object_color" ||
5475          name=="selection_element_color" ||
5476          name==        "highlight_color" ||
5477          name=="selection_precision_node"    ||
5478          name=="selection_precision_element" ||
5479          name=="selection_precision_object"   ||
5480          name=="selection_increment")
5481     {
5482       SMESH::UpdateSelectionProp( this );
5483     }
5484     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5485     {
5486       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5487       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5488       if ( sbX1+sbW > aTol ) {
5489         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5490         sbX1 = 0.01;
5491         sbW  = 0.08;
5492         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5493         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5494       }
5495     }
5496     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5497     {
5498       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5499       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5500       if ( sbY1 + sbH > aTol ) {
5501         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5502         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5503         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5504       }
5505     }
5506     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5507     {
5508       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5509       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5510       if ( sbX1 + sbW > aTol ) {
5511         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5512         sbX1=0.1;
5513         sbW =0.08;
5514         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5515         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5516       }
5517     }
5518     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5519     {
5520       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5521       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5522       if ( sbY1 + sbH > aTol ) {
5523         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5524         sbY1=0.01;
5525         sbH =0.08;
5526         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5527         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5528       }
5529     }
5530     else if ( name == "segmentation" )
5531     {
5532       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5533       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5534     }
5535     else if ( name == "nb_segments_per_edge" )
5536     {
5537       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5538       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5539     }
5540     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5541     {
5542       QString val = aResourceMgr->stringValue( "SMESH", name );
5543       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5544     }
5545     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5546     {
5547       SMESH::UpdateFontProp( this );
5548     }
5549     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5550     {
5551       SMESH::UpdateFontProp( this );
5552     }
5553
5554     if ( aWarning.size() != 0 ) {
5555       aWarning += "The default values are applied instead.";
5556       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5557                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5558                                QObject::tr(aWarning.c_str()));
5559     }
5560   }
5561 }
5562
5563 //================================================================================
5564 /*!
5565  * \brief Update something in accordance with update flags
5566   * \param theFlags - update flags
5567 *
5568 * Update viewer or/and object browser etc. in accordance with update flags ( see
5569 * LightApp_UpdateFlags enumeration ).
5570 */
5571 //================================================================================
5572 void SMESHGUI::update( const int flags )
5573 {
5574   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5575     SMESH::UpdateView();
5576   else
5577     SalomeApp_Module::update( flags );
5578 }
5579
5580 //================================================================================
5581 /*!
5582  * \brief Set default selection mode
5583 *
5584 * SLOT called when operation committed. Sets default selection mode
5585 */
5586 //================================================================================
5587 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5588 {
5589   SVTK_ViewWindow* vtkWnd =
5590     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5591   if ( vtkWnd )
5592     vtkWnd->SetSelectionMode( ActorSelection );
5593 }
5594
5595 //================================================================================
5596 /*!
5597  * \brief Set default selection mode
5598 *
5599 * SLOT called when operation aborted. Sets default selection mode
5600 */
5601 //================================================================================
5602 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5603 {
5604   SVTK_ViewWindow* vtkWnd =
5605     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5606   if ( vtkWnd )
5607     vtkWnd->SetSelectionMode( ActorSelection );
5608 }
5609
5610 //================================================================================
5611 /*!
5612  * \brief Creates operation with given identifier
5613   * \param id - identifier of operation to be started
5614   * \return Pointer on created operation or NULL if operation is not created
5615 *
5616 * Virtual method redefined from the base class creates operation with given id.
5617 * It is called called automatically from startOperation method of base class.
5618 */
5619 //================================================================================
5620 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5621 {
5622   LightApp_Operation* op = 0;
5623   // to do : create operation here
5624   switch( id )
5625   {
5626     case SMESHOp::OpSplitBiQuadratic:
5627       op = new SMESHGUI_SplitBiQuadOp();
5628     break;
5629     case SMESHOp::OpConvertMeshToQuadratic:
5630       op = new SMESHGUI_ConvToQuadOp();
5631     break;
5632     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5633       op = new SMESHGUI_Make2DFrom3DOp();
5634     break;
5635     case SMESHOp::OpReorientFaces:
5636       op = new SMESHGUI_ReorientFacesOp();
5637       break;
5638     case SMESHOp::OpCreateMesh:
5639       op = new SMESHGUI_MeshOp( true, true );
5640     break;
5641     case SMESHOp::OpCreateSubMesh:
5642       op = new SMESHGUI_MeshOp( true, false );
5643     break;
5644     case SMESHOp::OpEditMeshOrSubMesh:
5645     case SMESHOp::OpEditMesh:
5646     case SMESHOp::OpEditSubMesh:
5647       op = new SMESHGUI_MeshOp( false );
5648     break;
5649     case SMESHOp::OpCompute:
5650     case SMESHOp::OpComputeSubMesh:
5651       op = new SMESHGUI_ComputeOp();
5652     break;
5653     case SMESHOp::OpPreCompute:
5654       op = new SMESHGUI_PrecomputeOp();
5655     break;
5656     case SMESHOp::OpEvaluate:
5657       op = new SMESHGUI_EvaluateOp();
5658     break;
5659     case SMESHOp::OpMeshOrder:
5660       op = new SMESHGUI_MeshOrderOp();
5661     break;
5662     case SMESHOp::OpCreateGeometryGroup:
5663       op = new SMESHGUI_GroupOnShapeOp();
5664       break;
5665     case SMESHOp::OpFindElementByPoint:
5666       op = new SMESHGUI_FindElemByPointOp();
5667       break;
5668     case SMESHOp::OpMoveNode: // Make mesh pass through point
5669       op = new SMESHGUI_MakeNodeAtPointOp();
5670       break;
5671     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5672       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5673       break;
5674     default:
5675     break;
5676   }
5677
5678   if( !op )
5679     op = SalomeApp_Module::createOperation( id );
5680   return op;
5681 }
5682
5683 //================================================================================
5684 /*!
5685  * \brief Stops current operations and starts a given one
5686   * \param id - The id of the operation to start
5687  */
5688 //================================================================================
5689
5690 void SMESHGUI::switchToOperation(int id)
5691 {
5692   activeStudy()->abortAllOperations();
5693   startOperation( id );
5694 }
5695
5696 LightApp_Displayer* SMESHGUI::displayer()
5697 {
5698   if( !myDisplayer )
5699     myDisplayer = new SMESHGUI_Displayer( getApp() );
5700   return myDisplayer;
5701 }
5702
5703 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5704 {
5705   int aHue = -1;
5706   int aTolerance = 64;
5707   int anIterations = 0;
5708   int aPeriod = 5;
5709
5710   while( 1 )
5711   {
5712     anIterations++;
5713     if( anIterations % aPeriod == 0 )
5714     {
5715       aTolerance /= 2;
5716       if( aTolerance < 1 )
5717         break;
5718     }
5719
5720     aHue = (int)( 360.0 * rand() / RAND_MAX );
5721
5722     bool ok = true;
5723     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5724     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5725     for( ; it != itEnd; ++it )
5726     {
5727       SALOMEDS::Color anAutoColor = *it;
5728       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5729
5730       int h, s, v;
5731       aQColor.getHsv( &h, &s, &v );
5732       if( abs( h - aHue ) < aTolerance )
5733       {
5734         ok = false;
5735         break;
5736       }
5737     }
5738
5739     if( ok )
5740       break;
5741   }
5742
5743   QColor aColor;
5744   aColor.setHsv( aHue, 255, 255 );
5745
5746   SALOMEDS::Color aSColor;
5747   aSColor.R = aColor.redF();
5748   aSColor.G = aColor.greenF();
5749   aSColor.B = aColor.blueF();
5750
5751   return aSColor;
5752 }
5753
5754 const char* gSeparator = "_"; // character used to separate parameter names
5755 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5756 const char* gPathSep   = "|"; // character used to separate paths
5757
5758 /*!
5759  * \brief Store visual parameters
5760  *
5761  * This method is called just before the study document is saved.
5762  * Store visual parameters in AttributeParameter attribute(s)
5763  */
5764 void SMESHGUI::storeVisualParameters (int savePoint)
5765 {
5766   // localizing
5767   Kernel_Utils::Localizer loc;
5768
5769   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5770   if (!appStudy || !appStudy->studyDS())
5771     return;
5772   _PTR(Study) studyDS = appStudy->studyDS();
5773
5774   // componentName is used for encoding of entries when storing them in IParameters
5775   std::string componentName = myComponentSMESH->ComponentDataType();
5776   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5777   //if (!aSComponent) return;
5778
5779   // IParameters
5780   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5781                                                              componentName.c_str(),
5782                                                              savePoint);
5783   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5784
5785   // store custom markers
5786   if( !myMarkerMap.empty() )
5787   {
5788     VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5789     for( ; anIter != myMarkerMap.end(); anIter++ )
5790     {
5791       int anId = anIter->first;
5792       VTK::MarkerData aMarkerData = anIter->second;
5793       std::string aMarkerFileName = aMarkerData.first;
5794       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5795       if( aMarkerTexture.size() < 3 )
5796         continue; // should contain at least width, height and the first value
5797
5798       QString aPropertyName( "texture" );
5799       aPropertyName += gSeparator;
5800       aPropertyName += QString::number( anId );
5801
5802       QString aPropertyValue = aMarkerFileName.c_str();
5803       aPropertyValue += gPathSep;
5804
5805       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5806       ushort aWidth = *aTextureIter++;
5807       ushort aHeight = *aTextureIter++;
5808       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5809       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5810       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5811         aPropertyValue += QString::number( *aTextureIter );
5812
5813       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5814     }
5815   }
5816
5817   // viewers counters are used for storing view_numbers in IParameters
5818   int vtkViewers = 0;
5819
5820   // main cycle to store parameters of displayed objects
5821   QList<SUIT_ViewManager*> lst;
5822   QList<SUIT_ViewManager*>::Iterator it;
5823   getApp()->viewManagers(lst);
5824   for (it = lst.begin(); it != lst.end(); it++)
5825   {
5826     SUIT_ViewManager* vman = *it;
5827     QString vType = vman->getType();
5828
5829     // saving VTK actors properties
5830     if (vType == SVTK_Viewer::Type())
5831     {
5832       // store the clipping planes attached to the view manager
5833       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5834       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5835       if( anIter != myClippingPlaneInfoMap.end() )
5836         aClippingPlaneInfoList = anIter->second;
5837
5838       if( !aClippingPlaneInfoList.empty() ) {
5839         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5840         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5841         {
5842           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5843           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5844
5845           QString aPropertyName( "ClippingPlane" );
5846           aPropertyName += gSeparator;
5847           aPropertyName += QString::number( vtkViewers );
5848           aPropertyName += gSeparator;
5849           aPropertyName += QString::number( anId );
5850
5851           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5852           aPropertyValue += gDigitsSep;
5853           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5854           aPropertyValue += gDigitsSep;
5855           if ( aPlane->PlaneMode == SMESH::Absolute ) {
5856             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5857             aPropertyValue += gDigitsSep;
5858             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5859             aPropertyValue += gDigitsSep;
5860             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5861             aPropertyValue += gDigitsSep;
5862             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5863             aPropertyValue += gDigitsSep;
5864             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5865             aPropertyValue += gDigitsSep;
5866             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5867             aPropertyValue += gDigitsSep;
5868             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5869           }
5870           else if ( aPlane->PlaneMode == SMESH::Relative ) {
5871             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5872             aPropertyValue += gDigitsSep;
5873             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5874             aPropertyValue += gDigitsSep;
5875             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5876             aPropertyValue += gDigitsSep;
5877             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5878           }
5879
5880           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5881         }
5882       }
5883
5884       QVector<SUIT_ViewWindow*> views = vman->getViews();
5885       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5886       {
5887         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5888         {
5889           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5890           vtkActorCollection* allActors = aCopy.GetActors();
5891           allActors->InitTraversal();
5892           while (vtkActor* actor = allActors->GetNextActor())
5893           {
5894             if (actor->GetVisibility()) // store only visible actors
5895             {
5896               SMESH_Actor* aSmeshActor = 0;
5897               if (actor->IsA("SMESH_Actor"))
5898                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5899               if (aSmeshActor && aSmeshActor->hasIO())
5900               {
5901                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5902                 if (io->hasEntry())
5903                 {
5904                   // entry is "encoded" = it does NOT contain component address,
5905                   // since it is a subject to change on next component loading
5906                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5907
5908                   std::string param, vtkParam = vType.toLatin1().data();
5909                   vtkParam += gSeparator;
5910                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5911                   vtkParam += gSeparator;
5912
5913                   // Visibility
5914                   param = vtkParam + "Visibility";
5915                   ip->setParameter(entry, param, "On");
5916
5917                   // Representation
5918                   param = vtkParam + "Representation";
5919                   ip->setParameter(entry, param, QString::number
5920                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5921
5922                   // IsShrunk
5923                   param = vtkParam + "IsShrunk";
5924                   ip->setParameter(entry, param, QString::number
5925                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5926
5927                   // Displayed entities
5928                   unsigned int aMode = aSmeshActor->GetEntityMode();
5929                   bool isE  = aMode & SMESH_Actor::eEdges;
5930                   bool isF  = aMode & SMESH_Actor::eFaces;
5931                   bool isV  = aMode & SMESH_Actor::eVolumes;
5932                   bool is0d = aMode & SMESH_Actor::e0DElements;
5933                   bool isB  = aMode & SMESH_Actor::eBallElem;
5934
5935                   QString modeStr ("e");
5936                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5937                   modeStr += gDigitsSep; modeStr += "f";
5938                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5939                   modeStr += gDigitsSep; modeStr += "v";
5940                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5941                   modeStr += gDigitsSep; modeStr += "0d";
5942                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5943                   modeStr += gDigitsSep; modeStr += "b";
5944                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5945
5946                   param = vtkParam + "Entities";
5947                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5948
5949                   // Colors
5950                   double r, g, b;
5951                   int delta;
5952
5953                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5954                   QStringList colorStr;
5955                   colorStr << "surface";
5956                   colorStr << QString::number(r);
5957                   colorStr << QString::number(g);
5958                   colorStr << QString::number(b);
5959
5960                   colorStr << "backsurface";
5961                   colorStr << QString::number(delta);
5962
5963                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5964                   colorStr << "volume";
5965                   colorStr << QString::number(r);
5966                   colorStr << QString::number(g);
5967                   colorStr << QString::number(b);
5968                   colorStr << QString::number(delta);
5969
5970                   aSmeshActor->GetEdgeColor(r, g, b);
5971                   colorStr << "edge";
5972                   colorStr << QString::number(r);
5973                   colorStr << QString::number(g);
5974                   colorStr << QString::number(b);
5975
5976                   aSmeshActor->GetNodeColor(r, g, b);
5977                   colorStr << "node";
5978                   colorStr << QString::number(r);
5979                   colorStr << QString::number(g);
5980                   colorStr << QString::number(b);
5981
5982                   aSmeshActor->GetOutlineColor(r, g, b);
5983                   colorStr << "outline";
5984                   colorStr << QString::number(r);
5985                   colorStr << QString::number(g);
5986                   colorStr << QString::number(b);
5987
5988                   aSmeshActor->Get0DColor(r, g, b);
5989                   colorStr << "elem0d";
5990                   colorStr << QString::number(r);
5991                   colorStr << QString::number(g);
5992                   colorStr << QString::number(b);
5993
5994                   aSmeshActor->GetBallColor(r, g, b);
5995                   colorStr << "ball";
5996                   colorStr << QString::number(r);
5997                   colorStr << QString::number(g);
5998                   colorStr << QString::number(b);
5999
6000                   aSmeshActor->GetFacesOrientationColor(r, g, b);
6001                   colorStr << "orientation";
6002                   colorStr << QString::number(r);
6003                   colorStr << QString::number(g);
6004                   colorStr << QString::number(b);
6005
6006                   param = vtkParam + "Colors";
6007                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6008
6009                   // Sizes
6010                   QStringList sizeStr;
6011                   sizeStr << "line";
6012                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6013                   sizeStr << "outline";
6014                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6015                   sizeStr << "elem0d";
6016                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6017                   sizeStr << "ball";
6018                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6019                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6020                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6021                   sizeStr << "shrink";
6022                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6023                   sizeStr << "orientation";
6024                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6025                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6026
6027                   param = vtkParam + "Sizes";
6028                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6029
6030                   // Point marker
6031                   QString markerStr;
6032
6033                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6034                   if( aMarkerType == VTK::MT_USER ) {
6035                     markerStr += "custom";
6036                     markerStr += gDigitsSep;
6037                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6038                   }
6039                   else {
6040                     markerStr += "std";
6041                     markerStr += gDigitsSep;
6042                     markerStr += QString::number( (int)aMarkerType );
6043                     markerStr += gDigitsSep;
6044                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6045                   }
6046
6047                   param = vtkParam + "PointMarker";
6048                   ip->setParameter(entry, param, markerStr.toLatin1().data());
6049
6050                   // Opacity
6051                   param = vtkParam + "Opacity";
6052                   ip->setParameter(entry, param,
6053                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6054
6055                   // Clipping
6056                   param = vtkParam + "ClippingPlane";
6057                   int aPlaneId = 0;
6058                   if( !aClippingPlaneInfoList.empty() ) {
6059                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6060                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6061                     {
6062                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6063                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6064                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
6065                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6066                         if( aSmeshActor == *anIter2 ) {
6067                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6068                                             QString::number( anId ).toLatin1().constData() );
6069                           break;
6070                         }
6071                       }
6072                     }
6073                   }
6074                   if( aPlaneId == 0 )
6075                     ip->setParameter( entry, param, "Off" );
6076                 } // if (io->hasEntry())
6077               } // SMESH_Actor && hasIO
6078             } // isVisible
6079           } // while.. actors traversal
6080         } // if (vtkView)
6081       } // for (views)
6082       vtkViewers++;
6083     } // if (SVTK view model)
6084   } // for (viewManagers)
6085 }
6086
6087 // data structures for clipping planes processing
6088 typedef struct {
6089   int Id;
6090   int Mode;
6091   bool isOpenGLClipping;
6092   vtkIdType RelativeOrientation;
6093   double Distance;
6094   double Angle[2];
6095   int AbsoluteOrientation;
6096   double X, Y, Z, Dx, Dy, Dz;
6097 } TPlaneData;
6098 typedef std::list<TPlaneData>         TPlaneDataList;
6099 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6100
6101 typedef std::list<vtkActor*>          TActorList;
6102 typedef struct {
6103   int PlaneId;
6104   TActorList ActorList;
6105   SUIT_ViewManager* ViewManager;
6106 } TPlaneInfo;
6107 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6108 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6109
6110 /*!
6111  * \brief Restore visual parameters
6112  *
6113  * This method is called after the study document is opened.
6114  * Restore visual parameters from AttributeParameter attribute(s)
6115  */
6116 void SMESHGUI::restoreVisualParameters (int savePoint)
6117 {
6118   // localizing
6119   Kernel_Utils::Localizer loc;
6120
6121   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6122   if (!appStudy || !appStudy->studyDS())
6123     return;
6124   _PTR(Study) studyDS = appStudy->studyDS();
6125
6126   // componentName is used for encoding of entries when storing them in IParameters
6127   std::string componentName = myComponentSMESH->ComponentDataType();
6128   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6129   //if (!aSComponent) return;
6130
6131   // IParameters
6132   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6133                                                              componentName.c_str(),
6134                                                              savePoint);
6135   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6136
6137   // restore custom markers and map of clipping planes
6138   TPlaneDataMap aPlaneDataMap;
6139
6140   std::vector<std::string> properties = ip->getProperties();
6141   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6142   {
6143     std::string property = *propIt;
6144     QString aPropertyName( property.c_str() );
6145     QString aPropertyValue( ip->getProperty( property ).c_str() );
6146
6147     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6148     if( aPropertyNameList.isEmpty() )
6149       continue;
6150
6151     QString aPropertyType = aPropertyNameList[0];
6152     if( aPropertyType == "texture" )
6153     {
6154       if( aPropertyNameList.size() != 2 )
6155         continue;
6156
6157       bool ok = false;
6158       int anId = aPropertyNameList[1].toInt( &ok );
6159       if( !ok || anId < 1 )
6160         continue;
6161
6162       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6163       if( aPropertyValueList.size() != 2 )
6164         continue;
6165
6166       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6167       QString aMarkerTextureString = aPropertyValueList[1];
6168       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6169       if( aMarkerTextureStringList.size() != 3 )
6170         continue;
6171
6172       ok = false;
6173       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6174       if( !ok )
6175         continue;
6176
6177       ok = false;
6178       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6179       if( !ok )
6180         continue;
6181
6182       VTK::MarkerTexture aMarkerTexture;
6183       aMarkerTexture.push_back( aWidth );
6184       aMarkerTexture.push_back( aHeight );
6185
6186       QString aMarkerTextureData = aMarkerTextureStringList[2];
6187       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6188       {
6189         QChar aChar = aMarkerTextureData.at( i );
6190         if( aChar.isDigit() )
6191           aMarkerTexture.push_back( aChar.digitValue() );
6192       }
6193
6194       myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6195     }
6196     else if( aPropertyType == "ClippingPlane" )
6197     {
6198       if( aPropertyNameList.size() != 3 )
6199         continue;
6200
6201       bool ok = false;
6202       int aViewId = aPropertyNameList[1].toInt( &ok );
6203       if( !ok || aViewId < 0 )
6204         continue;
6205
6206       ok = false;
6207       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6208       if( !ok || aClippingPlaneId < 0 )
6209         continue;
6210
6211       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6212       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6213         continue;
6214
6215       TPlaneData aPlaneData;
6216       aPlaneData.AbsoluteOrientation = false;
6217       aPlaneData.RelativeOrientation = 0;
6218       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6219       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6220       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6221
6222       aPlaneData.Id = aClippingPlaneId;
6223
6224       ok = false;
6225       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6226       if( !ok )
6227         continue;
6228
6229       ok = false;
6230       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6231       if( !ok )
6232         continue;
6233
6234       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6235       {
6236         ok = false;
6237         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6238         if( !ok )
6239           continue;
6240
6241         ok = false;
6242         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6243         if( !ok )
6244           continue;
6245
6246         ok = false;
6247         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6248         if( !ok )
6249           continue;
6250
6251         ok = false;
6252         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6253         if( !ok )
6254           continue;
6255
6256         ok = false;
6257         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6258         if( !ok )
6259           continue;
6260
6261         ok = false;
6262         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6263         if( !ok )
6264           continue;
6265
6266         ok = false;
6267         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6268         if( !ok )
6269           continue;
6270       }
6271       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6272         ok = false;
6273         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6274         if( !ok )
6275           continue;
6276
6277         ok = false;
6278         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6279         if( !ok )
6280           continue;
6281
6282         ok = false;
6283         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6284         if( !ok )
6285           continue;
6286
6287         ok = false;
6288         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6289         if( !ok )
6290           continue;
6291       }
6292
6293       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6294       aPlaneDataList.push_back( aPlaneData );
6295     }
6296   }
6297
6298   TPlaneInfoMap aPlaneInfoMap;
6299
6300   std::vector<std::string> entries = ip->getEntries();
6301
6302   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6303   {
6304     // entry is a normal entry - it should be "decoded" (setting base address of component)
6305     QString entry (ip->decodeEntry(*entIt).c_str());
6306
6307     // Check that the entry corresponds to a real object in the Study
6308     // as the object may be deleted or modified after the visual state is saved.
6309     _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6310     if (!so) continue; //Skip the not existent entry
6311
6312     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6313     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6314
6315     std::vector<std::string>::iterator namesIt = paramNames.begin();
6316     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6317
6318     // actors are stored in a map after displaying of them for
6319     // quicker access in the future: map < viewID to actor >
6320     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6321
6322     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6323     {
6324       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6325       // '_' is used as separator and should not be used in viewer type or parameter names.
6326       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6327       if (lst.size() != 3)
6328         continue;
6329
6330       QString viewerTypStr = lst[0];
6331       QString viewIndexStr = lst[1];
6332       QString paramNameStr = lst[2];
6333
6334       bool ok;
6335       int viewIndex = viewIndexStr.toUInt(&ok);
6336       if (!ok) // bad conversion of view index to integer
6337         continue;
6338
6339       // viewers
6340       if (viewerTypStr == SVTK_Viewer::Type())
6341       {
6342         SMESH_Actor* aSmeshActor = 0;
6343         if (vtkActors.IsBound(viewIndex))
6344           aSmeshActor = vtkActors.Find(viewIndex);
6345
6346         QList<SUIT_ViewManager*> lst;
6347         getApp()->viewManagers(viewerTypStr, lst);
6348
6349         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6350         SUIT_ViewManager* vman = NULL;
6351         if (viewIndex >= 0 && viewIndex < lst.count())
6352           vman = lst.at(viewIndex);
6353
6354         if (paramNameStr == "Visibility")
6355         {
6356           if (!aSmeshActor && displayer() && vman)
6357           {
6358             SUIT_ViewModel* vmodel = vman->getViewModel();
6359             // SVTK view model can be casted to SALOME_View
6360             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6361
6362             // store displayed actor in a temporary map for quicker
6363             // access later when restoring other parameters
6364             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6365             vtkRenderer* Renderer = vtkView->getRenderer();
6366             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6367             vtkActorCollection* theActors = aCopy.GetActors();
6368             theActors->InitTraversal();
6369             bool isFound = false;
6370             vtkActor *ac = theActors->GetNextActor();
6371             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6372               if (ac->IsA("SMESH_Actor")) {
6373                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6374                 if (aGeomAc->hasIO()) {
6375                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6376                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6377                     isFound = true;
6378                     vtkActors.Bind(viewIndex, aGeomAc);
6379                   }
6380                 }
6381               }
6382             }
6383           }
6384         } // if (paramNameStr == "Visibility")
6385         else
6386         {
6387           // the rest properties "work" with SMESH_Actor
6388           if (aSmeshActor)
6389           {
6390             QString val ((*valuesIt).c_str());
6391
6392             // Representation
6393             if (paramNameStr == "Representation") {
6394               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6395             }
6396             // IsShrunk
6397             else if (paramNameStr == "IsShrunk") {
6398               if (val.toInt()) {
6399                 if (!aSmeshActor->IsShrunk())
6400                   aSmeshActor->SetShrink();
6401               }
6402               else {
6403                 if (aSmeshActor->IsShrunk())
6404                   aSmeshActor->UnShrink();
6405               }
6406             }
6407             // Displayed entities
6408             else if (paramNameStr == "Entities") {
6409               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6410               int aEntityMode = SMESH_Actor::eAllEntity;
6411               for ( int i = 0; i < mode.count(); i+=2 ) {
6412                 if ( i < mode.count()-1 ) {
6413                   QString type = mode[i];
6414                   bool val = mode[i+1].toInt();
6415                   if      ( type == "e" && !val )
6416                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6417                   else if ( type == "f" && !val )
6418                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6419                   else if ( type == "v" && !val )
6420                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6421                   else if ( type == "0d" && !val )
6422                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6423                   else if ( type == "b" && !val )
6424                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6425                 }
6426               }
6427               aSmeshActor->SetEntityMode( aEntityMode );
6428             }
6429             // Colors
6430             else if (paramNameStr == "Colors") {
6431               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6432               QColor nodeColor;
6433               QColor edgeColor;
6434               QColor faceColor;
6435               QColor volumeColor;
6436               QColor elem0dColor;
6437               QColor ballColor;
6438               QColor outlineColor;
6439               QColor orientationColor;
6440               int deltaF;
6441               int deltaV;
6442               QColor c;
6443               double r, g, b;
6444               bool bOk;
6445               // below lines are required to get default values for delta coefficients
6446               // of backface color for faces and color of reversed volumes
6447               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6448               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6449               for ( int i = 0; i < colors.count(); i++ ) {
6450                 QString type = colors[i];
6451                 if ( type == "surface" ) {
6452                   // face color is set by 3 values r:g:b, where
6453                   // - r,g,b - is rgb color components
6454                   if ( i+1 >= colors.count() ) break;                  // format error
6455                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6456                   if ( i+2 >= colors.count() ) break;                  // format error
6457                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6458                   if ( i+3 >= colors.count() ) break;                  // format error
6459                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6460                   faceColor.setRgbF( r, g, b );
6461                   i += 3;
6462                 }
6463                 else if ( type == "backsurface" ) {
6464                   // backface color can be defined in several ways
6465                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6466                   // - in latest versions, it is set as delta coefficient
6467                   bool rgbOk = false, deltaOk;
6468                   if ( i+1 >= colors.count() ) break;                  // format error
6469                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6470                   int delta = colors[i+1].toInt( &deltaOk );
6471                   i++;                                 // shift index
6472                   if ( i+1 < colors.count() )          // index is shifted to 1
6473                     g = colors[i+1].toDouble( &rgbOk );
6474                   if ( rgbOk ) i++;                    // shift index
6475                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6476                     b = colors[i+1].toDouble( &rgbOk );
6477                   if ( rgbOk ) i++;
6478                   // - as currently there's no way to set directly backsurface color as it was before,
6479                   // we ignore old dump where r,g,b triple was set
6480                   // - also we check that delta parameter is set properly
6481                   if ( !rgbOk && deltaOk )
6482                     deltaF = delta;
6483                 }
6484                 else if ( type == "volume" ) {
6485                   // volume color is set by 4 values r:g:b:delta, where
6486                   // - r,g,b - is a normal volume rgb color components
6487                   // - delta - is a reversed volume color delta coefficient
6488                   if ( i+1 >= colors.count() ) break;                  // format error
6489                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6490                   if ( i+2 >= colors.count() ) break;                  // format error
6491                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6492                   if ( i+3 >= colors.count() ) break;                  // format error
6493                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6494                   if ( i+4 >= colors.count() ) break;                  // format error
6495                   int delta = colors[i+4].toInt( &bOk );
6496                   if ( !bOk ) break;                                   // format error
6497                   volumeColor.setRgbF( r, g, b );
6498                   deltaV = delta;
6499                   i += 4;
6500                 }
6501                 else if ( type == "edge" ) {
6502                   // edge color is set by 3 values r:g:b, where
6503                   // - r,g,b - is rgb color components
6504                   if ( i+1 >= colors.count() ) break;                  // format error
6505                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6506                   if ( i+2 >= colors.count() ) break;                  // format error
6507                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6508                   if ( i+3 >= colors.count() ) break;                  // format error
6509                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6510                   edgeColor.setRgbF( r, g, b );
6511                   i += 3;
6512                 }
6513                 else if ( type == "node" ) {
6514                   // node color is set by 3 values r:g:b, where
6515                   // - r,g,b - is rgb color components
6516                   if ( i+1 >= colors.count() ) break;                  // format error
6517                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6518                   if ( i+2 >= colors.count() ) break;                  // format error
6519                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6520                   if ( i+3 >= colors.count() ) break;                  // format error
6521                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6522                   nodeColor.setRgbF( r, g, b );
6523                   i += 3;
6524                 }
6525                 else if ( type == "elem0d" ) {
6526                   // 0d element color is set by 3 values r:g:b, where
6527                   // - r,g,b - is rgb color components
6528                   if ( i+1 >= colors.count() ) break;                  // format error
6529                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6530                   if ( i+2 >= colors.count() ) break;                  // format error
6531                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6532                   if ( i+3 >= colors.count() ) break;                  // format error
6533                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6534                   elem0dColor.setRgbF( r, g, b );
6535                   i += 3;
6536                 }
6537                 else if ( type == "ball" ) {
6538                   // ball color is set by 3 values r:g:b, where
6539                   // - r,g,b - is rgb color components
6540                   if ( i+1 >= colors.count() ) break;                  // format error
6541                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6542                   if ( i+2 >= colors.count() ) break;                  // format error
6543                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6544                   if ( i+3 >= colors.count() ) break;                  // format error
6545                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6546                   ballColor.setRgbF( r, g, b );
6547                   i += 3;
6548                 }
6549                 else if ( type == "outline" ) {
6550                   // outline color is set by 3 values r:g:b, where
6551                   // - r,g,b - is rgb color components
6552                   if ( i+1 >= colors.count() ) break;                  // format error
6553                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6554                   if ( i+2 >= colors.count() ) break;                  // format error
6555                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6556                   if ( i+3 >= colors.count() ) break;                  // format error
6557                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6558                   outlineColor.setRgbF( r, g, b );
6559                   i += 3;
6560                 }
6561                 else if ( type == "orientation" ) {
6562                   // orientation color is set by 3 values r:g:b, where
6563                   // - r,g,b - is rgb color components
6564                   if ( i+1 >= colors.count() ) break;                  // format error
6565                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6566                   if ( i+2 >= colors.count() ) break;                  // format error
6567                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6568                   if ( i+3 >= colors.count() ) break;                  // format error
6569                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6570                   orientationColor.setRgbF( r, g, b );
6571                   i += 3;
6572                 }
6573               }
6574               // node color
6575               if ( nodeColor.isValid() )
6576                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6577               // edge color
6578               if ( edgeColor.isValid() )
6579                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6580               // face color
6581               if ( faceColor.isValid() )
6582                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6583               // volume color
6584               if ( volumeColor.isValid() )
6585                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6586               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6587                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6588               // 0d element color
6589               if ( elem0dColor.isValid() )
6590                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6591               // ball color
6592               if ( ballColor.isValid() )
6593                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6594               // outline color
6595               if ( outlineColor.isValid() )
6596                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6597               // orientation color
6598               if ( orientationColor.isValid() )
6599                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6600             }
6601             // Sizes
6602             else if (paramNameStr == "Sizes") {
6603               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6604               bool bOk;
6605               int lineWidth = -1;
6606               int outlineWidth = -1;
6607               int elem0dSize = -1;
6608               //int ballSize = -1;
6609               double ballDiameter = -1.0;
6610               double ballScale = -1.0;
6611               double shrinkSize = -1;
6612               double orientationSize = -1;
6613               bool orientation3d = false;
6614               for ( int i = 0; i < sizes.count(); i++ ) {
6615                 QString type = sizes[i];
6616                 if ( type == "line" ) {
6617                   // line (wireframe) width is given as single integer value
6618                   if ( i+1 >= sizes.count() ) break;                    // format error
6619                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6620                   lineWidth = v;
6621                   i++;
6622                 }
6623                 if ( type == "outline" ) {
6624                   // outline width is given as single integer value
6625                   if ( i+1 >= sizes.count() ) break;                    // format error
6626                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6627                   outlineWidth = v;
6628                   i++;
6629                 }
6630                 else if ( type == "elem0d" ) {
6631                   // 0d element size is given as single integer value
6632                   if ( i+1 >= sizes.count() ) break;                    // format error
6633                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6634                   elem0dSize = v;
6635                   i++;
6636                 }
6637                 else if ( type == "ball" ) {
6638                   // balls are specified by two values: size:scale, where
6639                   // - size - is a integer value specifying size
6640                   // - scale - is a double value specifying scale factor
6641                   if ( i+1 >= sizes.count() ) break;                       // format error
6642                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6643                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6644                   if ( i+2 >= sizes.count() ) break;                       // format error
6645                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6646                   //ballSize = v1;
6647                   ballDiameter = v1;
6648                   ballScale = v2;
6649                   i += 2;
6650                 }
6651                 else if ( type == "shrink" ) {
6652                   // shrink factor is given as single floating point value
6653                   if ( i+1 >= sizes.count() ) break;                          // format error
6654                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6655                   shrinkSize = v;
6656                   i++;
6657                 }
6658                 else if ( type == "orientation" ) {
6659                   // orientation vectors are specified by two values size:3d, where
6660                   // - size - is a floating point value specifying scale factor
6661                   // - 3d - is a boolean
6662                   if ( i+1 >= sizes.count() ) break;                          // format error
6663                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6664                   if ( i+2 >= sizes.count() ) break;                          // format error
6665                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6666                   orientationSize = v1;
6667                   orientation3d = (bool)v2;
6668                   i += 2;
6669                 }
6670               }
6671               // line (wireframe) width
6672               if ( lineWidth > 0 )
6673                 aSmeshActor->SetLineWidth( lineWidth );
6674               // outline width
6675               if ( outlineWidth > 0 )
6676                 aSmeshActor->SetOutlineWidth( outlineWidth );
6677               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6678                 aSmeshActor->SetOutlineWidth( lineWidth );
6679               // 0d element size
6680               if ( elem0dSize > 0 )
6681                 aSmeshActor->Set0DSize( elem0dSize );
6682               // ball size
6683               /*if ( ballSize > 0 )
6684                 aSmeshActor->SetBallSize( ballSize );*/
6685               // ball diameter
6686               if ( ballDiameter > 0 )
6687                 aSmeshActor->SetBallSize( ballDiameter );
6688               // ball scale
6689               if ( ballScale > 0.0 )
6690                 aSmeshActor->SetBallScale( ballScale );
6691               // shrink factor
6692               if ( shrinkSize > 0 )
6693                 aSmeshActor->SetShrinkFactor( shrinkSize );
6694               // orientation vectors
6695               if ( orientationSize > 0 ) {
6696                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6697                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6698               }
6699             }
6700             // Point marker
6701             else if (paramNameStr == "PointMarker") {
6702               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6703               if( data.count() >= 2 ) {
6704                 bool ok = false;
6705                 int aParam1 = data[1].toInt( &ok );
6706                 if( ok ) {
6707                   if( data[0] == "std" && data.count() == 3 ) {
6708                     int aParam2 = data[2].toInt( &ok );
6709                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6710                   }
6711                   else if( data[0] == "custom" ) {
6712                     VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6713                     if( markerIt != myMarkerMap.end() ) {
6714                       VTK::MarkerData aMarkerData = markerIt->second;
6715                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6716                     }
6717                   }
6718                 }
6719               }
6720             }
6721             // Opacity
6722             else if (paramNameStr == "Opacity") {
6723               aSmeshActor->SetOpacity(val.toFloat());
6724             }
6725             // Clipping
6726             else if (paramNameStr.startsWith("ClippingPlane")) {
6727               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6728               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6729               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6730               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6731               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6732               // new format - val looks like "Off" or "0" (plane id)
6733               // (note: in new format "Off" value is used only for consistency,
6734               //  so it is processed together with values in old format)
6735               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6736               if( anIsOldFormat ) {
6737                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6738                   aSmeshActor->RemoveAllClippingPlanes();
6739                 if (val != "Off") {
6740                   QList<SUIT_ViewManager*> lst;
6741                   getApp()->viewManagers(viewerTypStr, lst);
6742                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6743                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6744                     SUIT_ViewManager* vman = lst.at(viewIndex);
6745                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6746
6747                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6748
6749                     SMESH::TActorList anActorList;
6750                     anActorList.push_back( aSmeshActor );
6751                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6752                     aPlane->myViewWindow = vtkView;
6753                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6754                     aPlane->PlaneMode = aMode;
6755                     bool isOpenGLClipping = ( bool )vals[1].toInt();
6756                     aPlane->IsOpenGLClipping = isOpenGLClipping;
6757                     if ( aMode == SMESH::Absolute ) {
6758                       aPlane->myAbsoluteOrientation = vals[2].toInt();
6759                       aPlane->X = vals[3].toFloat();
6760                       aPlane->Y = vals[4].toFloat();
6761                       aPlane->Z = vals[5].toFloat();
6762                       aPlane->Dx = vals[6].toFloat();
6763                       aPlane->Dy = vals[7].toFloat();
6764                       aPlane->Dz = vals[8].toFloat();
6765                     }
6766                     else if ( aMode == SMESH::Relative ) {
6767                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6768                       aPlane->myDistance = vals[3].toFloat();
6769                       aPlane->myAngle[0] = vals[4].toFloat();
6770                       aPlane->myAngle[1] = vals[5].toFloat();
6771                     }
6772
6773                     if( aPlane ) {
6774                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6775                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6776                         aClippingPlaneInfo.Plane = aPlane;
6777                         aClippingPlaneInfo.ActorList = anActorList;
6778                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6779                       }
6780                     }
6781                   }
6782                 }
6783               }
6784               else {
6785                 bool ok = false;
6786                 int aPlaneId = val.toInt( &ok );
6787                 if( ok && aPlaneId >= 0 ) {
6788                   bool anIsDefinedPlane = false;
6789                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6790                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6791                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6792                     TPlaneInfo& aPlaneInfo = *anIter;
6793                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6794                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6795                       anIsDefinedPlane = true;
6796                       break;
6797                     }
6798                   }
6799                   if( !anIsDefinedPlane ) {
6800                     TPlaneInfo aPlaneInfo;
6801                     aPlaneInfo.PlaneId = aPlaneId;
6802                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6803                     aPlaneInfo.ViewManager = vman;
6804
6805                     // to make the list sorted by plane id
6806                     anIter = aPlaneInfoList.begin();
6807                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6808                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6809                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6810                         break;
6811                     }
6812                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6813                   }
6814                 }
6815               }
6816             }
6817           } // if (aSmeshActor)
6818         } // other parameters than Visibility
6819       }
6820     } // for names/parameters iterator
6821   } // for entries iterator
6822
6823   // take into account planes with empty list of actors referred to them
6824   QList<SUIT_ViewManager*> aVMList;
6825   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6826
6827   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6828   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6829     int aViewId = aPlaneDataIter->first;
6830     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6831       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6832
6833       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6834
6835       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6836       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6837       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6838         const TPlaneData& aPlaneData = *anIter2;
6839         int aPlaneId = aPlaneData.Id;
6840
6841         bool anIsFound = false;
6842         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6843         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6844           const TPlaneInfo& aPlaneInfo = *anIter3;
6845           if( aPlaneInfo.PlaneId == aPlaneId ) {
6846             anIsFound = true;
6847             break;
6848           }
6849         }
6850
6851         if( !anIsFound ) {
6852           TPlaneInfo aPlaneInfo; // ActorList field is empty
6853           aPlaneInfo.PlaneId = aPlaneId;
6854           aPlaneInfo.ViewManager = aViewManager;
6855
6856           // to make the list sorted by plane id
6857           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6858           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6859             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6860             if( aPlaneInfoRef.PlaneId > aPlaneId )
6861               break;
6862           }
6863           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6864         }
6865       }
6866     }
6867   }
6868
6869   // add clipping planes to actors according to the restored parameters
6870   // and update the clipping plane map
6871   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6872   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6873     int aViewId = anIter1->first;
6874     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6875
6876     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6877     if( anIter2 == aPlaneDataMap.end() )
6878       continue;
6879     const TPlaneDataList& aPlaneDataList = anIter2->second;
6880
6881     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6882     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6883       const TPlaneInfo& aPlaneInfo = *anIter3;
6884       int aPlaneId = aPlaneInfo.PlaneId;
6885       const TActorList& anActorList = aPlaneInfo.ActorList;
6886       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6887       if( !aViewManager )
6888         continue;
6889
6890       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6891       if( !aViewWindow )
6892         continue;
6893
6894       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6895
6896       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6897       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6898         const TPlaneData& aPlaneData = *anIter4;
6899         if( aPlaneData.Id == aPlaneId ) {
6900           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6901           aPlane->myViewWindow = aViewWindow;
6902           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6903           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6904           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6905             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6906             aPlane->X = aPlaneData.X;
6907             aPlane->Y = aPlaneData.Y;
6908             aPlane->Z = aPlaneData.Z;
6909             aPlane->Dx = aPlaneData.Dx;
6910             aPlane->Dy = aPlaneData.Dy;
6911             aPlane->Dz = aPlaneData.Dz;
6912           }
6913           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6914             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6915             aPlane->myDistance = aPlaneData.Distance;
6916             aPlane->myAngle[0] = aPlaneData.Angle[0];
6917             aPlane->myAngle[1] = aPlaneData.Angle[1];
6918           }
6919           if( aPlane ) {
6920             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6921               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6922               aClippingPlaneInfo.Plane = aPlane;
6923               aClippingPlaneInfo.ActorList = anActorList;
6924               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6925             }
6926           }
6927           break;
6928         }
6929       }
6930
6931     }
6932   }
6933
6934
6935   // update all VTK views
6936   QList<SUIT_ViewManager*> lst;
6937   getApp()->viewManagers(lst);
6938   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6939     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6940     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6941       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6942       // set OpenGL clipping planes
6943       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6944       vtkActorCollection* anAllActors = aCopy.GetActors();
6945       anAllActors->InitTraversal();
6946       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6947         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6948           anActor->SetOpenGLClippingPlane();
6949
6950       vtkView->getRenderer()->ResetCameraClippingRange();
6951       vtkView->Repaint();
6952     }
6953   }
6954 }
6955
6956 /*!
6957   \brief Adds preferences for dfont of VTK viewer
6958   \param label label
6959   \param pIf group identifier
6960   \param param parameter
6961   \return identifier of preferences
6962 */
6963 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6964 {
6965   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6966
6967   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6968
6969   QStringList fam;
6970   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6971   fam.append( tr( "SMESH_FONT_COURIER" ) );
6972   fam.append( tr( "SMESH_FONT_TIMES" ) );
6973
6974   setPreferenceProperty( tfont, "fonts", fam );
6975
6976   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6977   if ( needSize ) f = f | QtxFontEdit::Size;
6978   setPreferenceProperty( tfont, "features", f );
6979
6980   return tfont;
6981 }
6982
6983 /*!
6984   \brief Actions after hypothesis edition
6985   Updates object browser after hypothesis edition
6986 */
6987 void SMESHGUI::onHypothesisEdit( int result )
6988 {
6989   if( result == 1 )
6990     SMESHGUI::Modified();
6991   updateObjBrowser( true );
6992 }
6993
6994 /*!
6995   \brief Actions after choosing menu of control modes
6996   Updates control mode actions according to current selection
6997 */
6998 void SMESHGUI::onUpdateControlActions()
6999 {
7000   SALOME_ListIO selected;
7001   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7002     aSel->selectedObjects( selected );
7003
7004   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7005   if ( selected.Extent() ) {
7006     if ( selected.First()->hasEntry() ) {
7007       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7008         aControl = anActor->GetControlMode();
7009         SALOME_ListIteratorOfListIO it(selected);
7010         for ( it.Next(); it.More(); it.Next() ) {
7011           Handle(SALOME_InteractiveObject) anIO = it.Value();
7012           if ( anIO->hasEntry() ) {
7013             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7014               if ( aControl != anActor->GetControlMode() ) {
7015                 aControl = SMESH_Actor::eNone;
7016                 break;
7017               }
7018             }
7019           }
7020         }
7021       }
7022     }
7023   }
7024
7025   int anAction = ActionToControl( aControl, true );
7026   if ( anAction)
7027     action( anAction )->setChecked( true );
7028   else {
7029     QMenu* send = (QMenu*)sender();
7030     QList<QAction*> actions = send->actions();
7031     for ( int i = 0; i < actions.size(); i++ )
7032       actions[i]->setChecked( false );
7033   }
7034 }
7035
7036
7037 /*!
7038   \brief Signal handler closing(SUIT_ViewWindow*) of a view
7039   \param pview view being closed
7040 */
7041 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7042 #ifndef DISABLE_PLOT2DVIEWER
7043   //Crear all Plot2d Viewers if need.
7044   SMESH::ClearPlot2Viewers(pview);
7045 #endif
7046   EmitSignalCloseView();
7047 }
7048
7049 void SMESHGUI::message( const QString& msg )
7050 {
7051   // dispatch message
7052   QStringList data = msg.split("/");
7053   if ( data.count() > 0 ) {
7054     if ( data.first() == "mesh_loading" ) {
7055       // get mesh entry
7056       QString entry = data.count() > 1 ? data[1] : QString();
7057       if ( entry.isEmpty() )
7058         return;
7059       // get study
7060       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7061       // get mesh name
7062       _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7063       QString name;
7064       if ( obj )
7065         name = SMESH::fromUtf8(obj->GetName());
7066       if ( name.isEmpty() )
7067         return;
7068
7069       if ( data.last() == "stop" )
7070         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7071       else
7072         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7073       QApplication::processEvents();
7074     }
7075   }
7076 }
7077
7078 /*!
7079   \brief Connects or disconnects signals about activating and cloning view on the module slots
7080   \param pview view which is connected/disconnected
7081 */
7082 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7083   if(!pview)
7084     return;
7085
7086   SUIT_ViewManager* viewMgr = pview->getViewManager();
7087   if ( viewMgr ) {
7088     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7089                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7090
7091     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7092              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7093   }
7094 }
7095
7096 /*!
7097   \brief Return \c true if object can be renamed
7098 */
7099 bool SMESHGUI::renameAllowed( const QString& entry) const {
7100   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7101   if( !anApp )
7102     return false;
7103
7104   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7105   if( !appStudy )
7106     return false;
7107
7108   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7109
7110   if(!obj)
7111     return false;
7112
7113   if(appStudy->isComponent(entry) || obj->isReference())
7114     return false;
7115
7116   // check type to prevent renaming of inappropriate objects
7117   int aType = SMESHGUI_Selection::type(qPrintable(entry));
7118   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7119       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7120       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7121       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7122       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7123     return true;
7124
7125   return false;
7126 }
7127
7128 /*!
7129   Rename object by entry.
7130   \param entry entry of the object
7131   \param name new name of the object
7132   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7133 */
7134 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7135
7136   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7137   if( !anApp )
7138     return false;
7139
7140   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7141
7142   if(!appStudy)
7143     return false;
7144
7145   _PTR(Study) aStudy = appStudy->studyDS();
7146
7147   if(!aStudy)
7148     return false;
7149
7150   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7151   if ( aLocked ) {
7152     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7153     return false;
7154   }
7155
7156
7157   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7158   _PTR(GenericAttribute) anAttr;
7159   _PTR(AttributeName) aName;
7160   if ( obj ) {
7161     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7162       aName = anAttr;
7163       // check type to prevent renaming of inappropriate objects
7164       int aType = SMESHGUI_Selection::type( qPrintable(entry));
7165       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7166           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7167           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7168           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7169           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7170         if ( !name.isEmpty() ) {
7171           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7172
7173           // update name of group object and its actor
7174           Handle(SALOME_InteractiveObject) IObject =
7175             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7176
7177           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7178           if( !aGroupObject->_is_nil() ) {
7179             aGroupObject->SetName( qUtf8Printable(name) );
7180             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7181               anActor->setName( qUtf8Printable(name) );
7182           }
7183           return true;
7184         }
7185       }
7186     }
7187   }
7188   return false;
7189 }
7190
7191 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7192 {
7193   static QList<QColor> colors;
7194
7195   if ( colors.isEmpty() ) {
7196
7197     for (int s = 0; s < 2 ; s++)
7198     {
7199       for (int v = 100; v >= 40; v = v - 20)
7200       {
7201         for (int h = 0; h < 359 ; h = h + 60)
7202         {
7203           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7204         }
7205       }
7206     }
7207   }
7208   static int currentColor = randomize( colors.size() );
7209
7210   SALOMEDS::Color color;
7211   color.R = (double)colors[currentColor].red()   / 255.0;
7212   color.G = (double)colors[currentColor].green() / 255.0;
7213   color.B = (double)colors[currentColor].blue()  / 255.0;
7214
7215   currentColor = (currentColor+1) % colors.count();
7216
7217   return color;
7218 }