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