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