src/SMESHGUI/SMESHGUI.cxx

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