src/SMESHGUI/SMESHGUI.cxx

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