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_Add0DElemsOnAllNodesDlg.h"
  34 #include "SMESHGUI_AddMeshElementDlg.h"
  35 #include "SMESHGUI_AddQuadraticElementDlg.h"
  36 #include "SMESHGUI_BuildCompoundDlg.h"
  37 #include "SMESHGUI_ClippingDlg.h"
  38 #include "SMESHGUI_ComputeDlg.h"
  39 #include "SMESHGUI_ConvToQuadOp.h"
  40 #include "SMESHGUI_CopyMeshDlg.h"
  41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
  42 #include "SMESHGUI_DeleteGroupDlg.h"
  43 #include "SMESHGUI_DisplayEntitiesDlg.h"
  44 #include "SMESHGUI_Displayer.h"
  45 #include "SMESHGUI_DuplicateNodesDlg.h"
  46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
  47 #include "SMESHGUI_ExtrusionDlg.h"
  48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
  49 #include "SMESHGUI_FieldSelectorWdg.h"
  50 #include "SMESHGUI_FileInfoDlg.h"
  51 #include "SMESHGUI_FileValidator.h"
  52 #include "SMESHGUI_FilterDlg.h"
  53 #include "SMESHGUI_FilterLibraryDlg.h"
  54 #include "SMESHGUI_FilterUtils.h"
  55 #include "SMESHGUI_FindElemByPointDlg.h"
  56 #include "SMESHGUI_GEOMGenUtils.h"
  57 #include "SMESHGUI_GroupDlg.h"
  58 #include "SMESHGUI_GroupOnShapeDlg.h"
  59 #include "SMESHGUI_GroupOpDlg.h"
  60 #include "SMESHGUI_GroupUtils.h"
  61 #include "SMESHGUI_Hypotheses.h"
  62 #include "SMESHGUI_HypothesesUtils.h"
  63 #include "SMESHGUI_Make2DFrom3DOp.h"
  64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
  65 #include "SMESHGUI_Measurements.h"
  66 #include "SMESHGUI_MergeDlg.h"
  67 #include "SMESHGUI_MeshInfo.h"
  68 #include "SMESHGUI_MeshOp.h"
  69 #include "SMESHGUI_MeshOrderOp.h"
  70 #include "SMESHGUI_MeshPatternDlg.h"
  71 #include "SMESHGUI_MeshUtils.h"
  72 #include "SMESHGUI_MultiEditDlg.h"
  73 #include "SMESHGUI_NodesDlg.h"
  74 #include "SMESHGUI_OffsetDlg.h"
  75 #include "SMESHGUI_Operations.h"
  76 #include "SMESHGUI_PatternUtils.h"
  77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
  78 #include "SMESHGUI_PropertiesDlg.h"
  79 #include "SMESHGUI_RemoveElementsDlg.h"
  80 #include "SMESHGUI_RemoveNodesDlg.h"
  81 #include "SMESHGUI_RenumberingDlg.h"
  82 #include "SMESHGUI_ReorientFacesDlg.h"
  83 #include "SMESHGUI_RevolutionDlg.h"
  84 #include "SMESHGUI_RotationDlg.h"
  85 #include "SMESHGUI_ScaleDlg.h"
  86 #include "SMESHGUI_Selection.h"
  87 #include "SMESHGUI_SewingDlg.h"
  88 #include "SMESHGUI_SingleEditDlg.h"
  89 #include "SMESHGUI_SmoothingDlg.h"
  90 #include "SMESHGUI_SpinBox.h"
  91 #include "SMESHGUI_SplitBiQuad.h"
  92 #include "SMESHGUI_SymmetryDlg.h"
  93 #include "SMESHGUI_TranslationDlg.h"
  94 #include "SMESHGUI_TransparencyDlg.h"
  95 #include "SMESHGUI_Utils.h"
  96 #include "SMESHGUI_VTKUtils.h"
  97
  98 #include "SMESH_version.h"
  99
 100 #include "SMESH_Actor.h"
 101 #include "SMESH_ActorUtils.h"
 102 #include "SMESH_Client.hxx"
 103 #include "SMESH_Comment.hxx"
 104 #include "SMESH_ControlsDef.hxx"
 105 #include "SMESH_ScalarBarActor.h"
 106 #include "SMESH_TypeFilter.hxx"
 107
 108 // SALOME GUI includes
 109 #include <LightApp_DataOwner.h>
 110 #include <LightApp_NameDlg.h>
 111 #include <LightApp_Preferences.h>
 112 #include <LightApp_SelectionMgr.h>
 113 #include <LightApp_UpdateFlags.h>
 114 #include <QtxFontEdit.h>
 115 #include <QtxPopupMgr.h>
 116 #include <QtxInfoPanel.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   case SMESHOp::OpSplitBiQuadratic:
3038   case SMESHOp::OpConvertMeshToQuadratic:
3039   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3040   case SMESHOp::OpReorientFaces:
3041   case SMESHOp::OpCreateGeometryGroup:
3042     {
3043       if ( warnOnGeomModif() )
3044         break; // action forbiden as geometry modified
3045       startOperation( theCommandID );
3046       break;
3047     }
3048   case SMESHOp::OpCreateGroup:
3049     {
3050       if ( !vtkwnd )
3051       {
3052         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3053         break;
3054       }
3055
3056       if(isStudyLocked()) break;
3057       if ( warnOnGeomModif() )
3058         break; // action forbiden as geometry modified
3059       EmitSignalDeactivateDialog();
3060       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3061
3062       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3063       SALOME_ListIO selected;
3064       if( aSel )
3065         aSel->selectedObjects( selected );
3066
3067       int nbSel = selected.Extent();
3068       if (nbSel == 1) {
3069         // check if mesh is selected
3070         aMesh = SMESH::GetMeshByIO( selected.First() );
3071       }
3072       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3073       aDlg->show();
3074       break;
3075     }
3076
3077   case SMESHOp::OpConstructGroup:
3078     {
3079       if ( !vtkwnd )
3080       {
3081         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3082         break;
3083       }
3084
3085       if(isStudyLocked()) break;
3086       if ( warnOnGeomModif() )
3087         break; // action forbiden as geometry modified
3088       EmitSignalDeactivateDialog();
3089
3090       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3091       SALOME_ListIO selected;
3092       if( aSel )
3093         aSel->selectedObjects( selected );
3094
3095       int nbSel = selected.Extent();
3096       if (nbSel == 1) {
3097         // check if submesh is selected
3098         Handle(SALOME_InteractiveObject) IObject = selected.First();
3099         if (IObject->hasEntry()) {
3100           _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3101           if( aSObj ) {
3102             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3103             if (!aSubMesh->_is_nil()) {
3104               try {
3105                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3106                 // get submesh elements list by types
3107                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3108                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3109                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3110                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3111                 // create group for each type o elements
3112                 QString aName = IObject->getName();
3113                 QStringList anEntryList;
3114                 if (aNodes->length() > 0) {
3115                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3116                   aGroup->Add(aNodes.inout());
3117                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3118                     anEntryList.append( aSObject->GetID().c_str() );
3119                 }
3120                 if (aEdges->length() > 0) {
3121                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3122                   aGroup->Add(aEdges.inout());
3123                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3124                     anEntryList.append( aSObject->GetID().c_str() );
3125                 }
3126                 if (aFaces->length() > 0) {
3127                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3128                   aGroup->Add(aFaces.inout());
3129                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3130                     anEntryList.append( aSObject->GetID().c_str() );
3131                 }
3132                 if (aVolumes->length() > 0) {
3133                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3134                   aGroup->Add(aVolumes.inout());
3135                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3136                     anEntryList.append( aSObject->GetID().c_str() );
3137                 }
3138                 updateObjBrowser();
3139                 anApp->browseObjects( anEntryList );
3140               }
3141               catch(const SALOME::SALOME_Exception & S_ex){
3142                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3143               }
3144             }
3145           }
3146         }
3147       }
3148       else if(nbSel==0) {
3149         SUIT_MessageBox::warning(desktop(),
3150                                  tr("SMESH_WRN_WARNING"),
3151                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3152       }
3153       break;
3154     }
3155
3156   case SMESHOp::OpEditGroup:
3157     {
3158       if ( !vtkwnd )
3159       {
3160         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3161         break;
3162       }
3163
3164       if(isStudyLocked()) break;
3165       if ( warnOnGeomModif() )
3166         break; // action forbiden as geometry modified
3167       EmitSignalDeactivateDialog();
3168
3169       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3170       SALOME_ListIO selected;
3171       if( aSel )
3172         aSel->selectedObjects( selected );
3173
3174       SALOME_ListIteratorOfListIO It (selected);
3175       int nbSelectedGroups = 0;
3176       for ( ; It.More(); It.Next() )
3177       {
3178         SMESH::SMESH_GroupBase_var aGroup =
3179           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3180         if (!aGroup->_is_nil()) {
3181           nbSelectedGroups++;
3182           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3183           aDlg->show();
3184         }
3185       }
3186       if (nbSelectedGroups == 0)
3187         {
3188           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3189           aDlg->show();
3190         }
3191       break;
3192     }
3193
3194   case SMESHOp::OpAddElemGroupPopup:     // Add elements to group
3195     {
3196       if(isStudyLocked()) break;
3197       if (myState == 800) {
3198         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3199         if (aDlg) aDlg->onAdd();
3200       }
3201       break;
3202     }
3203
3204   case SMESHOp::OpRemoveElemGroupPopup:  // Remove elements from group
3205     {
3206       if(isStudyLocked()) break;
3207       if (myState == 800) {
3208         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3209         if (aDlg) aDlg->onRemove();
3210       }
3211       break;
3212     }
3213
3214   case SMESHOp::OpEditGeomGroupAsGroup:
3215     {
3216       if ( !vtkwnd )
3217       {
3218         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3219         break;
3220       }
3221
3222       if(isStudyLocked()) break;
3223       EmitSignalDeactivateDialog();
3224
3225       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3226       SALOME_ListIO selected;
3227       if( aSel )
3228         aSel->selectedObjects( selected );
3229
3230       SALOME_ListIteratorOfListIO It (selected);
3231       for ( ; It.More(); It.Next() )
3232       {
3233         SMESH::SMESH_GroupOnGeom_var aGroup =
3234           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3235         if (!aGroup->_is_nil()) {
3236           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3237           aDlg->show();
3238         }
3239         else
3240         {
3241           SMESH::SMESH_GroupOnFilter_var aGroup =
3242             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3243           if (!aGroup->_is_nil()) {
3244             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3245             aDlg->show();
3246           }
3247         }
3248       }
3249       break;
3250     }
3251
3252     case SMESHOp::OpUnionGroups:
3253     case SMESHOp::OpIntersectGroups:
3254     case SMESHOp::OpCutGroups:
3255     {
3256       if ( !vtkwnd )
3257       {
3258         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3259         break;
3260       }
3261
3262       if ( isStudyLocked() )
3263         break;
3264       if ( warnOnGeomModif() )
3265         break; // action forbiden as geometry modified
3266
3267       EmitSignalDeactivateDialog();
3268
3269       SMESHGUI_GroupOpDlg* aDlg = 0;
3270       if ( theCommandID == SMESHOp::OpUnionGroups )
3271         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3272       else if ( theCommandID == SMESHOp::OpIntersectGroups )
3273         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3274       else
3275         aDlg = new SMESHGUI_CutGroupsDlg( this );
3276
3277       aDlg->show();
3278
3279       break;
3280     }
3281
3282     case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3283     {
3284       if ( isStudyLocked() )
3285         break;
3286       if ( warnOnGeomModif() )
3287         break; // action forbiden as geometry modified
3288
3289       EmitSignalDeactivateDialog();
3290       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3291       aDlg->show();
3292
3293       break;
3294     }
3295
3296     case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3297     {
3298       if ( isStudyLocked() )
3299         break;
3300       if ( warnOnGeomModif() )
3301         break; // action forbiden as geometry modified
3302
3303       EmitSignalDeactivateDialog();
3304       SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3305       aDlg->show();
3306
3307       break;
3308     }
3309
3310     case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3311     {
3312       if ( !vtkwnd )
3313       {
3314         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3315         break;
3316       }
3317
3318       if ( isStudyLocked() )
3319         break;
3320
3321       EmitSignalDeactivateDialog();
3322
3323       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3324       break;
3325     }
3326
3327   case SMESHOp::OpMeshInformation:
3328   case SMESHOp::OpWhatIs:
3329     {
3330       int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3331       EmitSignalDeactivateDialog();
3332       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3333       SALOME_ListIO selected;
3334       if( aSel )
3335         aSel->selectedObjects( selected );
3336
3337       if ( selected.Extent() > 1 ) { // a dlg for each IO
3338         SALOME_ListIteratorOfListIO It( selected );
3339         for ( ; It.More(); It.Next() ) {
3340           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3341           dlg->showInfo( It.Value() );
3342           dlg->show();
3343         }
3344       }
3345       else {
3346         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3347         dlg->show();
3348       }
3349       break;
3350     }
3351
3352   case SMESHOp::OpFindElementByPoint:
3353     {
3354       startOperation( theCommandID );
3355       break;
3356     }
3357
3358   case SMESHOp::OpEditHypothesis:
3359     {
3360       if(isStudyLocked()) break;
3361       if ( warnOnGeomModif() )
3362         break; // action forbiden as geometry modified
3363
3364       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3365       SALOME_ListIO selected;
3366       if( aSel )
3367         aSel->selectedObjects( selected );
3368
3369       int nbSel = selected.Extent();
3370
3371       if (nbSel == 1) {
3372         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3373         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3374
3375         if ( !aHypothesis->_is_nil() )
3376         {
3377           SMESHGUI_GenericHypothesisCreator* aCreator =
3378             SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3379           if (aCreator)
3380           {
3381             // set geometry of mesh and sub-mesh to aCreator
3382             aSel->selectedObjects( selected, "",  /*convertReferences=*/false);
3383             if ( selected.Extent() == 1 )
3384             {
3385               QString subGeomID, meshGeomID;
3386               Handle(SALOME_InteractiveObject) hypIO = selected.First();
3387               if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3388               {
3389                 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3390                 aCreator->setShapeEntry( subGeomID );
3391                 aCreator->setMainShapeEntry( meshGeomID );
3392               }
3393             }
3394
3395             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3396           }
3397           else
3398           {
3399             // report error
3400           }
3401         }
3402       }
3403       break;
3404     }
3405   case SMESHOp::OpUnassign:                      // REMOVE HYPOTHESIS / ALGORITHMS
3406     {
3407       if(isStudyLocked()) break;
3408       if ( warnOnGeomModif() )
3409         break; // action forbiden as geometry modified
3410       SUIT_OverrideCursor wc;
3411
3412       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3413       SALOME_ListIO selected;
3414       if( aSel )
3415         aSel->selectedObjects( selected, QString::null, false );
3416
3417       SALOME_ListIteratorOfListIO It(selected);
3418       for (int i = 0; It.More(); It.Next(), i++) {
3419         Handle(SALOME_InteractiveObject) IObject = It.Value();
3420         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3421       }
3422       SALOME_ListIO l1;
3423       aSel->setSelectedObjects( l1 );
3424       updateObjBrowser();
3425       break;
3426     }
3427
3428   case SMESHOp::OpElem0D:
3429   case SMESHOp::OpBall:
3430   case SMESHOp::OpEdge:
3431   case SMESHOp::OpTriangle:
3432   case SMESHOp::OpQuadrangle:
3433   case SMESHOp::OpPolygon:
3434   case SMESHOp::OpTetrahedron:
3435   case SMESHOp::OpHexahedron:
3436   case SMESHOp::OpPentahedron:
3437   case SMESHOp::OpPyramid:
3438   case SMESHOp::OpHexagonalPrism:
3439     {
3440       if(isStudyLocked()) break;
3441       if ( warnOnGeomModif() )
3442         break; // action forbiden as geometry modified
3443       if ( vtkwnd ) {
3444         EmitSignalDeactivateDialog();
3445         SMDSAbs_EntityType type = SMDSEntity_Edge;
3446         switch (theCommandID) {
3447         case SMESHOp::OpElem0D: type = SMDSEntity_0D;                      break;
3448         case SMESHOp::OpBall: type = SMDSEntity_Ball;                      break;
3449         case SMESHOp::OpTriangle: type = SMDSEntity_Triangle;              break;
3450         case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle;          break;
3451         case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra;              break;
3452         case SMESHOp::OpPolygon: type = SMDSEntity_Polygon;                break;
3453         case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa;                break;
3454         case SMESHOp::OpPentahedron: type = SMDSEntity_Penta;              break;
3455         case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid;                break;
3456         case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3457         default:;
3458         }
3459         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3460       }
3461       else {
3462         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3463       }
3464       break;
3465     }
3466   case SMESHOp::OpPolyhedron:
3467     {
3468       if(isStudyLocked()) break;
3469       if ( warnOnGeomModif() )
3470         break; // action forbiden as geometry modified
3471       if ( vtkwnd ) {
3472         EmitSignalDeactivateDialog();
3473         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3474       }
3475       else {
3476         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3477       }
3478       break;
3479     }
3480   case SMESHOp::OpQuadraticEdge:
3481   case SMESHOp::OpQuadraticTriangle:
3482   case SMESHOp::OpBiQuadraticTriangle:
3483   case SMESHOp::OpQuadraticQuadrangle:
3484   case SMESHOp::OpBiQuadraticQuadrangle:
3485   case SMESHOp::OpQuadraticPolygon:
3486   case SMESHOp::OpQuadraticTetrahedron:
3487   case SMESHOp::OpQuadraticPyramid:
3488   case SMESHOp::OpQuadraticPentahedron:
3489   case SMESHOp::OpBiQuadraticPentahedron:
3490   case SMESHOp::OpQuadraticHexahedron:
3491   case SMESHOp::OpTriQuadraticHexahedron:
3492     {
3493       if(isStudyLocked()) break;
3494       if ( warnOnGeomModif() )
3495         break; // action forbiden as geometry modified
3496       if ( vtkwnd ) {
3497         EmitSignalDeactivateDialog();
3498         SMDSAbs_EntityType type = SMDSEntity_Last;
3499
3500         switch (theCommandID) {
3501         case SMESHOp::OpQuadraticEdge:          type = SMDSEntity_Quad_Edge; break;
3502         case SMESHOp::OpQuadraticTriangle:      type = SMDSEntity_Quad_Triangle; break;
3503         case SMESHOp::OpBiQuadraticTriangle:    type = SMDSEntity_BiQuad_Triangle; break;
3504         case SMESHOp::OpQuadraticQuadrangle:    type = SMDSEntity_Quad_Quadrangle; break;
3505         case SMESHOp::OpBiQuadraticQuadrangle:  type = SMDSEntity_BiQuad_Quadrangle; break;
3506         case SMESHOp::OpQuadraticPolygon:       type = SMDSEntity_Quad_Polygon; break;
3507         case SMESHOp::OpQuadraticTetrahedron:   type = SMDSEntity_Quad_Tetra; break;
3508         case SMESHOp::OpQuadraticPyramid:       type = SMDSEntity_Quad_Pyramid; break;
3509         case SMESHOp::OpQuadraticPentahedron:   type = SMDSEntity_Quad_Penta; break;
3510         case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3511         case SMESHOp::OpQuadraticHexahedron:    type = SMDSEntity_Quad_Hexa; break;
3512         case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3513         default: break;
3514         }
3515         if ( type != SMDSEntity_Last )
3516           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3517       }
3518       else {
3519         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3520                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3521       }
3522       break;
3523     }
3524   case SMESHOp::OpRemoveNodes:
3525     {
3526       if(isStudyLocked()) break;
3527       if ( warnOnGeomModif() )
3528         break; // action forbiden as geometry modified
3529       if ( vtkwnd ) {
3530         EmitSignalDeactivateDialog();
3531         ( new SMESHGUI_RemoveNodesDlg( this ) )->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::OpRemoveElements:                                    // REMOVES ELEMENTS
3540     {
3541       if(isStudyLocked()) break;
3542       if ( warnOnGeomModif() )
3543         break; // action forbiden as geometry modified
3544       if( vtkwnd ) {
3545         EmitSignalDeactivateDialog();
3546         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3547       }
3548       else
3549         {
3550           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3551                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3552         }
3553       break;
3554     }
3555   case SMESHOp::OpClearMesh: {
3556
3557     if(isStudyLocked()) break;
3558     if ( warnOnGeomModif() )
3559       break; // action forbiden as geometry modified
3560
3561     SALOME_ListIO selected;
3562     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3563       aSel->selectedObjects( selected );
3564
3565     SUIT_OverrideCursor wc;
3566     SALOME_ListIteratorOfListIO It (selected);
3567     for ( ; It.More(); It.Next() )
3568     {
3569       Handle(SALOME_InteractiveObject) IOS = It.Value();
3570       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3571       if ( aMesh->_is_nil()) continue;
3572       try {
3573         aMesh->Clear();
3574         if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3575           SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3576         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3577         // hide groups and submeshes
3578         _PTR(ChildIterator) anIter =
3579           SMESH::getStudy()->NewChildIterator( aMeshSObj );
3580         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3581         {
3582           _PTR(SObject) so = anIter->Value();
3583           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3584         }
3585       }
3586       catch (const SALOME::SALOME_Exception& S_ex){
3587         wc.suspend();
3588         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3589         wc.resume();
3590       }
3591     }
3592     SMESH::UpdateView();
3593     updateObjBrowser();
3594     break;
3595   }
3596   case SMESHOp::OpRemoveOrphanNodes:
3597     {
3598       if(isStudyLocked()) break;
3599       if ( warnOnGeomModif() )
3600         break; // action forbiden as geometry modified
3601       SALOME_ListIO selected;
3602       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3603         aSel->selectedObjects( selected );
3604       if ( selected.Extent() == 1 ) {
3605         Handle(SALOME_InteractiveObject) anIO = selected.First();
3606         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3607         if ( !aMesh->_is_nil() ) {
3608           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3609                                                     tr( "SMESH_WARNING" ),
3610                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3611                                                     SUIT_MessageBox::Yes |
3612                                                     SUIT_MessageBox::No,
3613                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3614           if( confirm ) {
3615             try {
3616               SUIT_OverrideCursor wc;
3617               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3618               int removed = aMeshEditor->RemoveOrphanNodes();
3619               SUIT_MessageBox::information(SMESHGUI::desktop(),
3620                                            tr("SMESH_INFORMATION"),
3621                                            tr("NB_NODES_REMOVED").arg(removed));
3622               if ( removed > 0 ) {
3623                 SMESH::UpdateView();
3624                 SMESHGUI::Modified();
3625               }
3626             }
3627             catch (const SALOME::SALOME_Exception& S_ex) {
3628               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3629             }
3630             catch (...) {
3631             }
3632           }
3633         }
3634       }
3635       break;
3636     }
3637   case SMESHOp::OpRenumberingNodes:
3638     {
3639       if(isStudyLocked()) break;
3640       if ( warnOnGeomModif() )
3641         break; // action forbiden as geometry modified
3642       if( vtkwnd ) {
3643         EmitSignalDeactivateDialog();
3644         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3645       }
3646       else
3647         {
3648           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3649                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3650         }
3651       break;
3652     }
3653   case SMESHOp::OpRenumberingElements:
3654     {
3655       if(isStudyLocked()) break;
3656       if ( warnOnGeomModif() )
3657         break; // action forbiden as geometry modified
3658       if ( vtkwnd ) {
3659         EmitSignalDeactivateDialog();
3660         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3661       }
3662       else
3663         {
3664           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3665                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3666         }
3667       break;
3668     }
3669   case SMESHOp::OpTranslation:
3670     {
3671       if(isStudyLocked()) break;
3672       if ( warnOnGeomModif() )
3673         break; // action forbiden as geometry modified
3674       if ( vtkwnd ) {
3675         EmitSignalDeactivateDialog();
3676         ( new SMESHGUI_TranslationDlg( this ) )->show();
3677       }
3678       else {
3679         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3680                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3681       }
3682       break;
3683     }
3684   case SMESHOp::OpRotation:
3685     {
3686       if(isStudyLocked()) break;
3687       if ( warnOnGeomModif() )
3688         break; // action forbiden as geometry modified
3689       if( vtkwnd ) {
3690         EmitSignalDeactivateDialog();
3691         ( new SMESHGUI_RotationDlg( 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::OpSymmetry:
3700     {
3701       if(isStudyLocked()) break;
3702       if ( warnOnGeomModif() )
3703         break; // action forbiden as geometry modified
3704       if(vtkwnd) {
3705         EmitSignalDeactivateDialog();
3706         ( new SMESHGUI_SymmetryDlg( 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::OpScale:
3715     {
3716       if(isStudyLocked()) break;
3717       if ( warnOnGeomModif() )
3718         break; // action forbiden as geometry modified
3719       if ( vtkwnd ) {
3720         EmitSignalDeactivateDialog();
3721         ( new SMESHGUI_ScaleDlg( 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
3730   case SMESHOp::OpOffset:
3731     {
3732       if(isStudyLocked()) break;
3733       if ( warnOnGeomModif() )
3734         break; // action forbiden as geometry modified
3735       if ( vtkwnd ) {
3736         EmitSignalDeactivateDialog();
3737         ( new SMESHGUI_OffsetDlg( this ) )->show();
3738       }
3739       else {
3740         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3741                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3742       }
3743       break;
3744     }
3745
3746   case SMESHOp::OpSewing:
3747     {
3748       if(isStudyLocked()) break;
3749       if ( warnOnGeomModif() )
3750         break; // action forbiden as geometry modified
3751       if(vtkwnd) {
3752         EmitSignalDeactivateDialog();
3753         ( new SMESHGUI_SewingDlg( this ) )->show();
3754       }
3755       else {
3756         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3757                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3758       }
3759       break;
3760     }
3761   case SMESHOp::OpMergeNodes:
3762     {
3763       if(isStudyLocked()) break;
3764       if ( warnOnGeomModif() )
3765         break; // action forbiden as geometry modified
3766       if(vtkwnd) {
3767         EmitSignalDeactivateDialog();
3768         ( new SMESHGUI_MergeDlg( this, 0 ) )->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::OpMergeElements:
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, 1 ) )->show();
3784       } else {
3785         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3786                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3787       }
3788       break;
3789     }
3790
3791   case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3792     if ( warnOnGeomModif() )
3793       break; // action forbiden as geometry modified
3794     startOperation( SMESHOp::OpMoveNode );
3795     break;
3796
3797   case SMESHOp::OpDuplicateNodes:
3798     {
3799       if(isStudyLocked()) break;
3800       if ( warnOnGeomModif() )
3801         break; // action forbiden as geometry modified
3802       if ( vtkwnd ) {
3803         EmitSignalDeactivateDialog();
3804         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3805       }
3806       else {
3807         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3808                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3809       }
3810       break;
3811     }
3812
3813   case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3814     if ( warnOnGeomModif() )
3815       break; // action forbiden as geometry modified
3816     startOperation( SMESHOp::OpElem0DOnElemNodes );
3817     break;
3818
3819   case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3820   {
3821     static QList<int> aTypes;
3822     if ( aTypes.isEmpty() )
3823     {
3824       aTypes.append( SMESH::NODE );
3825       aTypes.append( SMESH::EDGE );
3826       aTypes.append( SMESH::FACE );
3827       aTypes.append( SMESH::VOLUME );
3828     }
3829     if (!myFilterLibraryDlg)
3830       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3831     else if (myFilterLibraryDlg->isHidden())
3832       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3833     myFilterLibraryDlg->raise();
3834   }
3835   break;
3836   // CONTROLS
3837   case SMESHOp::OpFreeNode:
3838   case SMESHOp::OpEqualNode:
3839   case SMESHOp::OpNodeConnectivityNb:
3840   case SMESHOp::OpFreeEdge:
3841   case SMESHOp::OpFreeBorder:
3842   case SMESHOp::OpLength:
3843   case SMESHOp::OpConnection:
3844   case SMESHOp::OpEqualEdge:
3845   case SMESHOp::OpFreeFace:
3846   case SMESHOp::OpBareBorderFace:
3847   case SMESHOp::OpOverConstrainedFace:
3848   case SMESHOp::OpLength2D:
3849   case SMESHOp::OpDeflection2D:
3850   case SMESHOp::OpConnection2D:
3851   case SMESHOp::OpArea:
3852   case SMESHOp::OpTaper:
3853   case SMESHOp::OpAspectRatio:
3854   case SMESHOp::OpMinimumAngle:
3855   case SMESHOp::OpWarpingAngle:
3856   case SMESHOp::OpSkew:
3857   case SMESHOp::OpMaxElementLength2D:
3858   case SMESHOp::OpEqualFace:
3859   case SMESHOp::OpAspectRatio3D:
3860   case SMESHOp::OpVolume:
3861   case SMESHOp::OpMaxElementLength3D:
3862   case SMESHOp::OpBareBorderVolume:
3863   case SMESHOp::OpOverConstrainedVolume:
3864   case SMESHOp::OpEqualVolume:
3865     if ( vtkwnd ) {
3866
3867       LightApp_SelectionMgr* mgr = selectionMgr();
3868       SALOME_ListIO selected; mgr->selectedObjects( selected );
3869
3870       if( !selected.IsEmpty() ) {
3871         SUIT_OverrideCursor wc;
3872         ::Control( theCommandID );
3873         break;
3874       }
3875       SUIT_MessageBox::warning(desktop(),
3876                                tr( "SMESH_WRN_WARNING" ),
3877                                tr( "SMESH_BAD_SELECTION" ) );
3878       break;
3879     }
3880     else {
3881       SUIT_MessageBox::warning(desktop(),
3882                                tr( "SMESH_WRN_WARNING" ),
3883                                tr( "NOT_A_VTK_VIEWER" ) );
3884     }
3885     break;
3886   case SMESHOp::OpOverallMeshQuality:
3887     OverallMeshQuality();
3888     break;
3889   case SMESHOp::OpNumberingNodes:
3890     {
3891       SUIT_OverrideCursor wc;
3892       LightApp_SelectionMgr* mgr = selectionMgr();
3893       SALOME_ListIO selected; mgr->selectedObjects( selected );
3894
3895       SALOME_ListIteratorOfListIO it(selected);
3896       for( ; it.More(); it.Next()) {
3897         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3898         if(anIObject->hasEntry()) {
3899           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3900             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3901           }
3902         }
3903       }
3904       break;
3905     }
3906   case SMESHOp::OpNumberingElements:
3907     {
3908       SUIT_OverrideCursor wc;
3909       LightApp_SelectionMgr* mgr = selectionMgr();
3910       SALOME_ListIO selected; mgr->selectedObjects( selected );
3911
3912       SALOME_ListIteratorOfListIO it(selected);
3913       for( ; it.More(); it.Next()) {
3914         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3915         if(anIObject->hasEntry())
3916           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3917             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3918           }
3919       }
3920       break;
3921     }
3922   case SMESHOp::OpPropertiesLength:
3923   case SMESHOp::OpPropertiesArea:
3924   case SMESHOp::OpPropertiesVolume:
3925   case SMESHOp::OpMinimumDistance:
3926   case SMESHOp::OpBoundingBox:
3927   case SMESHOp::OpAngle:
3928     {
3929       int page = SMESHGUI_MeasureDlg::MinDistance;
3930       if ( theCommandID == SMESHOp::OpBoundingBox )
3931         page = SMESHGUI_MeasureDlg::BoundingBox;
3932       else if ( theCommandID == SMESHOp::OpPropertiesLength )
3933         page = SMESHGUI_MeasureDlg::Length;
3934       else if ( theCommandID == SMESHOp::OpPropertiesArea )
3935         page = SMESHGUI_MeasureDlg::Area;
3936       else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3937         page = SMESHGUI_MeasureDlg::Volume;
3938       else if ( theCommandID == SMESHOp::OpAngle )
3939         page = SMESHGUI_MeasureDlg::Angle;
3940
3941       EmitSignalDeactivateDialog();
3942       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3943       dlg->show();
3944       break;
3945     }
3946   case SMESHOp::OpSortChild:
3947     ::sortChildren();
3948     break;
3949   case SMESHOp::OpBreakLink:
3950     ::breakShaperLink();
3951     break;
3952
3953   }
3954
3955   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3956   //updateObjBrowser();
3957   return true;
3958 }
3959
3960 //=============================================================================
3961 /*!
3962  *
3963  */
3964 //=============================================================================
3965 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3966 {
3967   return false;
3968 }
3969
3970 //=============================================================================
3971 /*!
3972  *
3973  */
3974 //=============================================================================
3975 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3976 {
3977   return true;
3978 }
3979
3980 //=============================================================================
3981 /*!
3982  *
3983  */
3984 //=============================================================================
3985 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3986 {
3987   return true;
3988 }
3989
3990 //=============================================================================
3991 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3992  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3993  */
3994 //=============================================================================
3995 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3996                                   SUIT_ViewWindow* wnd )
3997 {
3998   if(theIO->hasEntry()){
3999     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4000     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4001   }
4002 }
4003
4004 //=======================================================================
4005 // function : createSMESHAction
4006 // purpose  :
4007 //=======================================================================
4008 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4009                                   const int key, const bool toggle, const QString& shortcutAction  )
4010 {
4011   QIcon icon;
4012   QWidget* parent = application()->desktop();
4013   SUIT_ResourceMgr* resMgr = resourceMgr();
4014   QPixmap pix;
4015   if ( !icon_id.isEmpty() )
4016     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4017   else
4018     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4019   if ( !pix.isNull() )
4020     icon = QIcon( pix );
4021
4022   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4023           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4024           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4025
4026   createAction( id, tooltip, icon, menu, status_bar, key, parent,
4027                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4028 }
4029
4030 //=======================================================================
4031 // function : createPopupItem
4032 // purpose  :
4033 //=======================================================================
4034 void SMESHGUI::createPopupItem( const int id,
4035                                 const QString& clients,
4036                                 const QString& types,
4037                                 const QString& theRule,
4038                                 const int pId )
4039 {
4040   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4041     popupMgr()->insert( action( id ), pId, 0 );
4042
4043   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4044   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4045   QString rule = "(%1) and (%2) and (%3)";
4046   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4047   if( clients.isEmpty() )
4048     rule = rule.arg( QString( "true" ) );
4049   else
4050     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4051   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4052   rule += theRule;
4053
4054   bool cont = myRules.contains( id );
4055   if( cont )
4056     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4057
4058   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4059   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4060 }
4061
4062 //=======================================================================
4063 // function : initialize
4064 // purpose  :
4065 //=======================================================================
4066 void SMESHGUI::initialize( CAM_Application* app )
4067 {
4068   SalomeApp_Module::initialize( app );
4069
4070 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
4071 //   if ( mgr )
4072   /* Automatic Update flag */
4073 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4074
4075   // ----- create actions --------------
4076
4077   //createSMESHAction(  SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4078   createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4079   createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4080   createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL"  );
4081 #ifdef WITH_CGNS
4082   createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4083 #endif
4084   createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4085   createSMESHAction( SMESHOp::OpImportGMF,  "IMPORT_GMF"  );
4086   createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4087   createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4088   createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL"  );
4089 #ifdef WITH_CGNS
4090   createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4091 #endif
4092   createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4093   createSMESHAction( SMESHOp::OpPopupImportGMF,  "IMPORT_GMF"  );
4094
4095   createSMESHAction( SMESHOp::OpExportDAT,  "DAT" );
4096   createSMESHAction( SMESHOp::OpExportMED,  "MED" );
4097   createSMESHAction( SMESHOp::OpExportUNV,  "UNV" );
4098   createSMESHAction( SMESHOp::OpExportSTL,  "STL" );
4099 #ifdef WITH_CGNS
4100   createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4101 #endif
4102   createSMESHAction( SMESHOp::OpExportSAUV,     "SAUV");
4103   createSMESHAction( SMESHOp::OpExportGMF,      "GMF" );
4104   createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4105   createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4106   createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4107   createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4108 #ifdef WITH_CGNS
4109   createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4110 #endif
4111   createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4112   createSMESHAction( SMESHOp::OpPopupExportGMF,  "GMF" );
4113   createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4114   createSMESHAction( SMESHOp::OpDelete,          "DELETE", "ICON_DELETE", Qt::Key_Delete );
4115   createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4116   createSMESHAction( SMESHOp::OpCreateMesh,           "CREATE_MESH",             "ICON_DLG_INIT_MESH" );
4117   createSMESHAction( SMESHOp::OpCreateSubMesh,        "CREATE_SUBMESH",          "ICON_DLG_ADD_SUBMESH" );
4118   createSMESHAction( SMESHOp::OpEditMeshOrSubMesh,    "EDIT_MESHSUBMESH",        "ICON_DLG_EDIT_MESH" );
4119   createSMESHAction( SMESHOp::OpEditMesh,             "EDIT_MESH",               "ICON_DLG_EDIT_MESH" );
4120   createSMESHAction( SMESHOp::OpEditSubMesh,          "EDIT_SUBMESH",            "ICON_DLG_EDIT_MESH" );
4121   createSMESHAction( SMESHOp::OpBuildCompoundMesh,    "BUILD_COMPOUND",          "ICON_BUILD_COMPOUND" );
4122   createSMESHAction( SMESHOp::OpCopyMesh,             "COPY_MESH",               "ICON_COPY_MESH" );
4123   createSMESHAction( SMESHOp::OpCompute,              "COMPUTE",                 "ICON_COMPUTE" );
4124   createSMESHAction( SMESHOp::OpComputeSubMesh,       "COMPUTE_SUBMESH",         "ICON_COMPUTE" );
4125   createSMESHAction( SMESHOp::OpRecompute,            "RE_COMPUTE",              "ICON_COMPUTE" );
4126   createSMESHAction( SMESHOp::OpPreCompute,           "PRECOMPUTE",              "ICON_PRECOMPUTE" );
4127   createSMESHAction( SMESHOp::OpShowErrors,           "SHOW_ERRORS",             "ICON_SHOW_ERRORS" );
4128   createSMESHAction( SMESHOp::OpEvaluate,             "EVALUATE",                "ICON_EVALUATE" );
4129   createSMESHAction( SMESHOp::OpMeshOrder,            "MESH_ORDER",              "ICON_MESH_ORDER");
4130   createSMESHAction( SMESHOp::OpCreateGroup,          "CREATE_GROUP",            "ICON_CREATE_GROUP" );
4131   createSMESHAction( SMESHOp::OpCreateGeometryGroup,  "CREATE_GEO_GROUP",        "ICON_CREATE_GEO_GROUP" );
4132   createSMESHAction( SMESHOp::OpConstructGroup,       "CONSTRUCT_GROUP",         "ICON_CONSTRUCT_GROUP" );
4133   createSMESHAction( SMESHOp::OpEditGroup,            "EDIT_GROUP",              "ICON_EDIT_GROUP" );
4134   createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4135   createSMESHAction( SMESHOp::OpUnionGroups,          "UN_GROUP",                "ICON_UNION" );
4136   createSMESHAction( SMESHOp::OpIntersectGroups,      "INT_GROUP",               "ICON_INTERSECT" );
4137   createSMESHAction( SMESHOp::OpCutGroups,            "CUT_GROUP",               "ICON_CUT" );
4138   createSMESHAction( SMESHOp::OpGroupUnderlyingElem,  "UNDERLYING_ELEMS",        "ICON_UNDERLYING_ELEMS" );
4139   createSMESHAction( SMESHOp::OpFaceGroupsByEdges,    "FACE_GROUPS_BY_EDGES",    "ICON_FACE_GROUPS_BY_EDGES" );
4140   createSMESHAction( SMESHOp::OpAddElemGroupPopup,    "ADD_TO_GROUP" );
4141   createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4142   createSMESHAction( SMESHOp::OpDeleteGroup,          "DEL_GROUP",               "ICON_DEL_GROUP" );
4143   createSMESHAction( SMESHOp::OpMeshInformation ,     "ADV_INFO",                "ICON_ADV_INFO" );
4144   //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO",        "ICON_STD_INFO" );
4145   //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4146   createSMESHAction( SMESHOp::OpFindElementByPoint,   "FIND_ELEM",               "ICON_FIND_ELEM" );
4147   //update
4148   createSMESHAction( SMESHOp::OpFreeNode,              "FREE_NODE",               "ICON_FREE_NODE",     0, true );
4149   createSMESHAction( SMESHOp::OpEqualNode,             "EQUAL_NODE",              "ICON_EQUAL_NODE",    0, true );
4150   createSMESHAction( SMESHOp::OpNodeConnectivityNb,    "NODE_CONNECTIVITY_NB",    "ICON_NODE_CONN_NB",    0, true );
4151   createSMESHAction( SMESHOp::OpFreeEdge,              "FREE_EDGE",               "ICON_FREE_EDGE",     0, true );
4152   createSMESHAction( SMESHOp::OpFreeBorder,            "FREE_BORDER",             "ICON_FREE_EDGE_2D",  0, true );
4153   createSMESHAction( SMESHOp::OpLength,                "LENGTH",                  "ICON_LENGTH",        0, true );
4154   createSMESHAction( SMESHOp::OpConnection,            "CONNECTION",              "ICON_CONNECTION",    0, true );
4155   createSMESHAction( SMESHOp::OpEqualEdge,             "EQUAL_EDGE",              "ICON_EQUAL_EDGE",    0, true );
4156   createSMESHAction( SMESHOp::OpFreeFace,              "FREE_FACES",              "ICON_FREE_FACES",    0, true );
4157   createSMESHAction( SMESHOp::OpBareBorderFace,        "BARE_BORDER_FACE",        "ICON_BARE_BORDER_FACE",        0, true );
4158   createSMESHAction( SMESHOp::OpOverConstrainedFace,   "OVER_CONSTRAINED_FACE",   "ICON_OVER_CONSTRAINED_FACE",   0, true );
4159   createSMESHAction( SMESHOp::OpLength2D,              "LENGTH_2D",               "ICON_LENGTH_2D",     0, true );
4160   createSMESHAction( SMESHOp::OpDeflection2D,          "DEFLECTION_2D",           "ICON_DEFLECTION_2D", 0, true );
4161   createSMESHAction( SMESHOp::OpConnection2D,          "CONNECTION_2D",           "ICON_CONNECTION_2D", 0, true );
4162   createSMESHAction( SMESHOp::OpArea,                  "AREA",                    "ICON_AREA",          0, true );
4163   createSMESHAction( SMESHOp::OpTaper,                 "TAPER",                   "ICON_TAPER",         0, true );
4164   createSMESHAction( SMESHOp::OpAspectRatio,           "ASPECT",                  "ICON_ASPECT",        0, true );
4165   createSMESHAction( SMESHOp::OpMinimumAngle,          "MIN_ANG",                 "ICON_ANGLE",         0, true );
4166   createSMESHAction( SMESHOp::OpWarpingAngle,          "WARP",                    "ICON_WARP",          0, true );
4167   createSMESHAction( SMESHOp::OpSkew,                  "SKEW",                    "ICON_SKEW",          0, true );
4168   createSMESHAction( SMESHOp::OpMaxElementLength2D,    "MAX_ELEMENT_LENGTH_2D",   "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
4169   createSMESHAction( SMESHOp::OpEqualFace,             "EQUAL_FACE",              "ICON_EQUAL_FACE",    0, true );
4170   createSMESHAction( SMESHOp::OpAspectRatio3D,         "ASPECT_3D",               "ICON_ASPECT_3D",     0, true );
4171   createSMESHAction( SMESHOp::OpVolume,                "VOLUME_3D",               "ICON_VOLUME_3D",     0, true );
4172   createSMESHAction( SMESHOp::OpMaxElementLength3D,    "MAX_ELEMENT_LENGTH_3D",   "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
4173   createSMESHAction( SMESHOp::OpBareBorderVolume,      "BARE_BORDER_VOLUME",      "ICON_BARE_BORDER_VOLUME",      0, true );
4174   createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4175   createSMESHAction( SMESHOp::OpEqualVolume,           "EQUAL_VOLUME",            "ICON_EQUAL_VOLUME",  0, true );
4176   createSMESHAction( SMESHOp::OpOverallMeshQuality,    "OVERALL_MESH_QUALITY",    "ICON_OVL_MESH_QUALITY" );
4177
4178   createSMESHAction( SMESHOp::OpNode,                   "NODE",            "ICON_DLG_NODE" );
4179   createSMESHAction( SMESHOp::OpElem0D,                 "ELEM0D",          "ICON_DLG_ELEM0D" );
4180   createSMESHAction( SMESHOp::OpElem0DOnElemNodes,      "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4181   createSMESHAction( SMESHOp::OpBall,                   "BALL",            "ICON_DLG_BALL" );
4182   createSMESHAction( SMESHOp::OpEdge,                   "EDGE",            "ICON_DLG_EDGE" );
4183   createSMESHAction( SMESHOp::OpTriangle,               "TRIANGLE",        "ICON_DLG_TRIANGLE" );
4184   createSMESHAction( SMESHOp::OpQuadrangle,             "QUAD",            "ICON_DLG_QUADRANGLE" );
4185   createSMESHAction( SMESHOp::OpPolygon,                "POLYGON",         "ICON_DLG_POLYGON" );
4186   createSMESHAction( SMESHOp::OpTetrahedron,            "TETRA",           "ICON_DLG_TETRAS" );
4187   createSMESHAction( SMESHOp::OpHexahedron,             "HEXA",            "ICON_DLG_HEXAS" );
4188   createSMESHAction( SMESHOp::OpPentahedron,            "PENTA",           "ICON_DLG_PENTA" );
4189   createSMESHAction( SMESHOp::OpPyramid ,               "PYRAMID",         "ICON_DLG_PYRAMID" );
4190   createSMESHAction( SMESHOp::OpHexagonalPrism,         "OCTA",            "ICON_DLG_OCTA" );
4191   createSMESHAction( SMESHOp::OpPolyhedron,             "POLYHEDRON",      "ICON_DLG_POLYHEDRON" );
4192   createSMESHAction( SMESHOp::OpQuadraticEdge,          "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
4193   createSMESHAction( SMESHOp::OpQuadraticTriangle,      "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
4194   createSMESHAction( SMESHOp::OpBiQuadraticTriangle,    "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4195   createSMESHAction( SMESHOp::OpQuadraticQuadrangle,    "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
4196   createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle,  "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4197   createSMESHAction( SMESHOp::OpQuadraticPolygon,       "QUADRATIC_POLYGON",       "ICON_DLG_QUADRATIC_POLYGON" );
4198   createSMESHAction( SMESHOp::OpQuadraticTetrahedron,   "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4199   createSMESHAction( SMESHOp::OpQuadraticPyramid,       "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
4200   createSMESHAction( SMESHOp::OpQuadraticPentahedron,   "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4201   createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4202   createSMESHAction( SMESHOp::OpQuadraticHexahedron,    "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4203   createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4204
4205   createSMESHAction( SMESHOp::OpRemoveNodes,       "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
4206   createSMESHAction( SMESHOp::OpRemoveElements,    "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
4207   createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
4208   createSMESHAction( SMESHOp::OpClearMesh,         "CLEAR_MESH",            "ICON_CLEAR_MESH" );
4209
4210   //createSMESHAction( SMESHOp::OpRenumberingNodes,    "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
4211   //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
4212
4213   createSMESHAction( SMESHOp::OpTranslation,            "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
4214   createSMESHAction( SMESHOp::OpRotation,               "ROT",             "ICON_DLG_MESH_ROTATION" );
4215   createSMESHAction( SMESHOp::OpSymmetry,               "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
4216   createSMESHAction( SMESHOp::OpScale,                  "SCALE",           "ICON_DLG_MESH_SCALE" );
4217   createSMESHAction( SMESHOp::OpOffset,                 "OFFSET",          "ICON_DLG_MESH_OFFSET" );
4218   createSMESHAction( SMESHOp::OpSewing,                 "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
4219   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
4220   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
4221   createSMESHAction( SMESHOp::OpMoveNode,               "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4222   createSMESHAction( SMESHOp::OpDuplicateNodes,         "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4223   createSMESHAction( SMESHOp::OpDiagonalInversion,      "INV",             "ICON_DLG_MESH_DIAGONAL" );
4224   createSMESHAction( SMESHOp::OpUnionOfTwoTriangle,     "UNION2",          "ICON_UNION2TRI" );
4225   createSMESHAction( SMESHOp::OpOrientation,            "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
4226   createSMESHAction( SMESHOp::OpReorientFaces,          "REORIENT_2D",     "ICON_REORIENT_2D" );
4227   createSMESHAction( SMESHOp::OpUnionOfTriangles,       "UNION",           "ICON_UNIONTRI" );
4228   createSMESHAction( SMESHOp::OpCuttingOfQuadrangles,   "CUT",             "ICON_CUTQUAD" );
4229   createSMESHAction( SMESHOp::OpSplitVolumes,           "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
4230   createSMESHAction( SMESHOp::OpSplitBiQuadratic,       "SPLIT_BIQUAD",    "ICON_SPLIT_BIQUAD" );
4231   createSMESHAction( SMESHOp::OpSmoothing,              "SMOOTH",          "ICON_DLG_SMOOTHING" );
4232   createSMESHAction( SMESHOp::OpExtrusion,              "EXTRUSION",       "ICON_EXTRUSION" );
4233   createSMESHAction( SMESHOp::OpExtrusionAlongAPath,    "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4234   createSMESHAction( SMESHOp::OpRevolution,             "REVOLUTION",      "ICON_REVOLUTION" );
4235   createSMESHAction( SMESHOp::OpPatternMapping,         "MAP",             "ICON_MAP" );
4236   createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
4237   createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
4238
4239   createSMESHAction( SMESHOp::OpReset,               "RESET" );
4240   createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4241   createSMESHAction( SMESHOp::OpShowScalarBar,       "SHOW_SCALAR_BAR","",0, true  );
4242   createSMESHAction( SMESHOp::OpSaveDistribution,    "SAVE_DISTRIBUTION" );
4243   createSMESHAction( SMESHOp::OpShowDistribution,    "SHOW_DISTRIBUTION","",0, true );
4244 #ifndef DISABLE_PLOT2DVIEWER
4245   createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4246 #endif
4247   createSMESHAction( SMESHOp::OpDMWireframe,  "WIRE",    "ICON_WIRE", 0, true );
4248   createSMESHAction( SMESHOp::OpDMShading,    "SHADE",   "ICON_SHADE", 0, true );
4249   createSMESHAction( SMESHOp::OpDMNodes,      "NODES",   "ICON_POINTS", 0, true );
4250   createSMESHAction( SMESHOp::OpDMShrink,     "SHRINK",  "ICON_SHRINK", 0, true );
4251   createSMESHAction( SMESHOp::OpUpdate,       "UPDATE",  "ICON_UPDATE" );
4252   createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4253   createSMESHAction( SMESHOp::OpDEEdges,      "EDGES",   "ICON_DLG_EDGE", 0, true );
4254   createSMESHAction( SMESHOp::OpDEFaces,      "FACES",   "ICON_DLG_TRIANGLE", 0, true );
4255   createSMESHAction( SMESHOp::OpDEVolumes,    "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4256   createSMESHAction( SMESHOp::OpDEBalls,      "BALLS",   "ICON_DLG_BALL", 0, true );
4257   createSMESHAction( SMESHOp::OpDEChoose,     "CHOOSE",  "ICON_DLG_CHOOSE", 0, false );
4258   createSMESHAction( SMESHOp::OpDEAllEntity,  "ALL",     "ICON_DLG_CHOOSE_ALL", 0, false );
4259   createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4260
4261   createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4262   createSMESHAction( SMESHOp::OpRepresentationArcs,  "ARC_REPRESENTATION", "", 0, true );
4263
4264   createSMESHAction( SMESHOp::OpEditHypothesis,    "EDIT_HYPO" );
4265   createSMESHAction( SMESHOp::OpUnassign,          "UNASSIGN" );
4266   createSMESHAction( SMESHOp::OpNumberingNodes,    "NUM_NODES", "", 0, true );
4267   createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4268   createSMESHAction( SMESHOp::OpProperties,   "COLORS" );
4269   createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4270   createSMESHAction( SMESHOp::OpClipping,     "CLIP" );
4271   createSMESHAction( SMESHOp::OpAutoColor,        "AUTO_COLOR" );
4272   createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4273
4274   createSMESHAction( SMESHOp::OpMinimumDistance,  "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4275   createSMESHAction( SMESHOp::OpBoundingBox,      "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
4276   createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH",   "ICON_MEASURE_LENGTH" );
4277   createSMESHAction( SMESHOp::OpPropertiesArea,   "MEASURE_AREA",     "ICON_MEASURE_AREA" );
4278   createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME",   "ICON_MEASURE_VOLUME" );
4279   createSMESHAction( SMESHOp::OpAngle,            "MEASURE_ANGLE",    "ICON_MEASURE_ANGLE" );
4280
4281   createSMESHAction( SMESHOp::OpHide,     "HIDE", "ICON_HIDE" );
4282   createSMESHAction( SMESHOp::OpShow,     "SHOW", "ICON_SHOW" );
4283   createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4284
4285   createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4286
4287   createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4288
4289   QList<int> aCtrlActions;
4290   aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4291                << SMESHOp::OpNodeConnectivityNb                                         // node controls
4292                << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4293                << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge    // edge controls
4294                << SMESHOp::OpDeflection2D
4295                << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4296                << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4297                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4298                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4299                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
4300                << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4301                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4302                << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
4303   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4304   aCtrlGroup->setExclusive( true );
4305   for( int i = 0; i < aCtrlActions.size(); i++ )
4306     aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4307
4308   // ----- create menu --------------
4309   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
4310       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
4311       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
4312       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
4313       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
4314       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
4315       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4316       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
4317
4318   createMenu( separator(), fileId );
4319
4320   QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4321   QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4322   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4323       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4324       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4325       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4326       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4327       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4328       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
4329       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4330     //renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
4331       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4332       basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4333
4334   //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4335   createMenu( SMESHOp::OpImportUNV,  importId, -1 );
4336   createMenu( SMESHOp::OpImportMED,  importId, -1 );
4337   createMenu( SMESHOp::OpImportSTL,  importId, -1 );
4338 #ifdef WITH_CGNS
4339   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4340 #endif
4341   createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4342   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
4343   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
4344   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
4345   createMenu( SMESHOp::OpExportUNV,  exportId, -1 );
4346   createMenu( SMESHOp::OpExportSTL,  exportId, -1 );
4347 #ifdef WITH_CGNS
4348   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4349 #endif
4350   createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4351   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
4352   createMenu( separator(), fileId, 10 );
4353
4354   createMenu( SMESHOp::OpDelete, editId, -1 );
4355
4356   createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4357
4358   createMenu( SMESHOp::OpCreateMesh,           meshId, -1 ); // "Mesh" menu
4359   createMenu( SMESHOp::OpCreateSubMesh,        meshId, -1 );
4360   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
4361   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
4362   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
4363   createMenu( separator(),                     meshId, -1 );
4364   createMenu( SMESHOp::OpCompute,              meshId, -1 );
4365   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
4366   createMenu( SMESHOp::OpEvaluate,             meshId, -1 );
4367   createMenu( SMESHOp::OpMeshOrder,            meshId, -1 );
4368   createMenu( separator(),                     meshId, -1 );
4369   createMenu( SMESHOp::OpCreateGroup,          meshId, -1 );
4370   createMenu( SMESHOp::OpCreateGeometryGroup,  meshId, -1 );
4371   createMenu( SMESHOp::OpConstructGroup,       meshId, -1 );
4372   createMenu( SMESHOp::OpEditGroup,            meshId, -1 );
4373   createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4374   createMenu( separator(),                     meshId, -1 );
4375   createMenu( SMESHOp::OpUnionGroups,          meshId, -1 );
4376   createMenu( SMESHOp::OpIntersectGroups,      meshId, -1 );
4377   createMenu( SMESHOp::OpCutGroups,            meshId, -1 );
4378   createMenu( separator(),                     meshId, -1 );
4379   createMenu( SMESHOp::OpGroupUnderlyingElem,  meshId, -1 );
4380   createMenu( SMESHOp::OpFaceGroupsByEdges,    meshId, -1 );
4381   createMenu( separator(),                     meshId, -1 );
4382   createMenu( SMESHOp::OpMeshInformation,      meshId, -1 );
4383   //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4384   //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4385   createMenu( SMESHOp::OpFindElementByPoint,   meshId, -1 );
4386   createMenu( separator(),                     meshId, -1 );
4387
4388   createMenu( SMESHOp::OpFreeNode,              nodeId,   -1 );
4389   createMenu( SMESHOp::OpEqualNode,             nodeId,   -1 );
4390   //createMenu( SMESHOp::OpNodeConnectivityNb,    nodeId,   -1 );
4391   createMenu( SMESHOp::OpFreeBorder,            edgeId,   -1 );
4392   createMenu( SMESHOp::OpLength,                edgeId,   -1 );
4393   createMenu( SMESHOp::OpConnection,            edgeId,   -1 );
4394   createMenu( SMESHOp::OpEqualEdge,             edgeId,   -1 );
4395   createMenu( SMESHOp::OpFreeEdge,              faceId,   -1 );
4396   createMenu( SMESHOp::OpFreeFace,              faceId,   -1 );
4397   createMenu( SMESHOp::OpBareBorderFace,        faceId,   -1 );
4398   createMenu( SMESHOp::OpOverConstrainedFace,   faceId,   -1 );
4399   createMenu( SMESHOp::OpLength2D,              faceId,   -1 );
4400   createMenu( SMESHOp::OpConnection2D,          faceId,   -1 );
4401   createMenu( SMESHOp::OpArea,                  faceId,   -1 );
4402   createMenu( SMESHOp::OpTaper,                 faceId,   -1 );
4403   createMenu( SMESHOp::OpAspectRatio,           faceId,   -1 );
4404   createMenu( SMESHOp::OpMinimumAngle,          faceId,   -1 );
4405   createMenu( SMESHOp::OpWarpingAngle,          faceId,   -1 );
4406   createMenu( SMESHOp::OpSkew,                  faceId,   -1 );
4407   createMenu( SMESHOp::OpMaxElementLength2D,    faceId,   -1 );
4408   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
4409   createMenu( SMESHOp::OpDeflection2D,          faceId,   -1 );
4410   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
4411   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
4412   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
4413   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
4414   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4415   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
4416   createMenu( separator(),                      ctrlId,   -1 );
4417   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
4418   createMenu( separator(),                      ctrlId,   -1 );
4419   createMenu( SMESHOp::OpOverallMeshQuality,    ctrlId,   -1 );
4420
4421   createMenu( SMESHOp::OpNode,                   addId, -1 );
4422   createMenu( SMESHOp::OpElem0D,                 addId, -1 );
4423   createMenu( SMESHOp::OpElem0DOnElemNodes,      addId, -1 );
4424   createMenu( SMESHOp::OpBall,                   addId, -1 );
4425   createMenu( SMESHOp::OpEdge,                   addId, -1 );
4426   createMenu( SMESHOp::OpTriangle,               addId, -1 );
4427   createMenu( SMESHOp::OpQuadrangle,             addId, -1 );
4428   createMenu( SMESHOp::OpPolygon,                addId, -1 );
4429   createMenu( SMESHOp::OpTetrahedron,            addId, -1 );
4430   createMenu( SMESHOp::OpHexahedron,             addId, -1 );
4431   createMenu( SMESHOp::OpPentahedron,            addId, -1 );
4432   createMenu( SMESHOp::OpPyramid,                addId, -1 );
4433   createMenu( SMESHOp::OpHexagonalPrism,         addId, -1 );
4434   createMenu( SMESHOp::OpPolyhedron,             addId, -1 );
4435   createMenu( separator(),                       addId, -1 );
4436   createMenu( SMESHOp::OpQuadraticEdge,          addId, -1 );
4437   createMenu( SMESHOp::OpQuadraticTriangle,      addId, -1 );
4438   createMenu( SMESHOp::OpBiQuadraticTriangle ,   addId, -1 );
4439   createMenu( SMESHOp::OpQuadraticQuadrangle,    addId, -1 );
4440   createMenu( SMESHOp::OpBiQuadraticQuadrangle,  addId, -1 );
4441   createMenu( SMESHOp::OpQuadraticPolygon,       addId, -1 );
4442   createMenu( SMESHOp::OpQuadraticTetrahedron,   addId, -1 );
4443   createMenu( SMESHOp::OpQuadraticPyramid,       addId, -1 );
4444   createMenu( SMESHOp::OpQuadraticPentahedron,   addId, -1 );
4445   createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4446   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
4447   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4448
4449   createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
4450   createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
4451   createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4452   createMenu( separator(),                  removeId, -1 );
4453   createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
4454   createMenu( separator(),                  removeId, -1 );
4455   createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
4456
4457   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
4458   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4459
4460   createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
4461   createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
4462   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
4463   createMenu( SMESHOp::OpRotation,       transfId, -1 );
4464   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
4465   createMenu( SMESHOp::OpScale,          transfId, -1 );
4466   createMenu( SMESHOp::OpOffset,         transfId, -1 );
4467   createMenu( SMESHOp::OpSewing,         transfId, -1 );
4468   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4469
4470   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4471   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4472   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
4473   createMenu( SMESHOp::OpExtrusionAlongAPath,    modifyId, -1 );
4474   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
4475   createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
4476   createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
4477   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
4478   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
4479   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
4480   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
4481   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
4482   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
4483   createMenu( SMESHOp::OpSplitBiQuadratic,       modifyId, -1 );
4484   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
4485   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
4486
4487   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
4488   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
4489   createMenu( SMESHOp::OpAngle,            measureId,   -1 );
4490   createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4491   createMenu( SMESHOp::OpPropertiesArea,   basicPropId, -1 );
4492   createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4493   createMenu( SMESHOp::OpUpdate,           viewId,      -1 );
4494
4495   connect( nodeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4496   connect( edgeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4497   connect( faceMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4498   connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4499
4500   // ----- create toolbars --------------
4501   int meshTb       = createTool( tr( "TB_MESH" ),      QString( "SMESHMeshToolbar" ) ),
4502       info         = createTool( tr( "TB_INFO" ),      QString( "SMESHInformationToolbar" ) ),
4503       groupTb      = createTool( tr( "TB_GROUP" ),     QString( "SMESHGroupToolbar" ) ),
4504       ctrl0dTb     = createTool( tr( "TB_CTRL0D" ),    QString( "SMESHNodeControlsToolbar" ) ),
4505       ctrl1dTb     = createTool( tr( "TB_CTRL1D" ),    QString( "SMESHEdgeControlsToolbar" ) ),
4506       ctrl2dTb     = createTool( tr( "TB_CTRL2D" ),    QString( "SMESHFaceControlsToolbar" ) ),
4507       ctrl3dTb     = createTool( tr( "TB_CTRL3D" ),    QString( "SMESHVolumeControlsToolbar" ) ),
4508       addElemTb    = createTool( tr( "TB_ADD" ),       QString( "SMESHAddElementToolbar" ) ),
4509       addNonElemTb = createTool( tr( "TB_ADDNON" ),    QString( "SMESHAddElementToolbar" ) ),
4510       remTb        = createTool( tr( "TB_REM" ),       QString( "SMESHRemoveToolbar" ) ),
4511     //renumbTb     = createTool( tr( "TB_RENUMBER" ),  QString( "SMESHRenumberingToolbar" ) ),
4512       transformTb  = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4513       modifyTb     = createTool( tr( "TB_MODIFY" ),    QString( "SMESHModificationToolbar" ) ),
4514       measuremTb   = createTool( tr( "TB_MEASUREM" ),  QString( "SMESHMeasurementsToolbar" ) ),
4515       dispModeTb   = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4516
4517   createTool( SMESHOp::OpCreateMesh,        meshTb );
4518   createTool( SMESHOp::OpCreateSubMesh,     meshTb );
4519   createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4520   createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4521   createTool( SMESHOp::OpCopyMesh,          meshTb );
4522   createTool( separator(),                  meshTb );
4523   createTool( SMESHOp::OpCompute,           meshTb );
4524   createTool( SMESHOp::OpPreCompute,        meshTb );
4525   createTool( SMESHOp::OpEvaluate,          meshTb );
4526   createTool( SMESHOp::OpMeshOrder,         meshTb );
4527
4528   createTool( SMESHOp::OpCreateGroup,         groupTb );
4529   createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4530   createTool( SMESHOp::OpConstructGroup,      groupTb );
4531   createTool( SMESHOp::OpEditGroup,           groupTb );
4532
4533   createTool( SMESHOp::OpMeshInformation,    info );
4534   //createTool( SMESHOp::OpStdInfo, meshTb );
4535   //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4536   createTool( SMESHOp::OpFindElementByPoint, info );
4537
4538   createTool( SMESHOp::OpFreeNode,  ctrl0dTb );
4539   createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4540   //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4541
4542   createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4543   createTool( SMESHOp::OpLength,     ctrl1dTb );
4544   createTool( SMESHOp::OpConnection, ctrl1dTb );
4545   createTool( SMESHOp::OpEqualEdge,  ctrl1dTb );
4546
4547   createTool( SMESHOp::OpFreeEdge,            ctrl2dTb );
4548   createTool( SMESHOp::OpFreeFace,            ctrl2dTb );
4549   createTool( SMESHOp::OpBareBorderFace,      ctrl2dTb );
4550   createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4551   createTool( SMESHOp::OpLength2D,            ctrl2dTb );
4552   createTool( SMESHOp::OpConnection2D,        ctrl2dTb );
4553   createTool( SMESHOp::OpArea,                ctrl2dTb );
4554   createTool( SMESHOp::OpTaper,               ctrl2dTb );
4555   createTool( SMESHOp::OpAspectRatio,         ctrl2dTb );
4556   createTool( SMESHOp::OpMinimumAngle,        ctrl2dTb );
4557   createTool( SMESHOp::OpWarpingAngle,        ctrl2dTb );
4558   createTool( SMESHOp::OpSkew,                ctrl2dTb );
4559   createTool( SMESHOp::OpMaxElementLength2D,  ctrl2dTb );
4560   createTool( SMESHOp::OpEqualFace,           ctrl2dTb );
4561   createTool( SMESHOp::OpDeflection2D,        ctrl2dTb );
4562
4563   createTool( SMESHOp::OpAspectRatio3D,         ctrl3dTb );
4564   createTool( SMESHOp::OpVolume,                ctrl3dTb );
4565   createTool( SMESHOp::OpMaxElementLength3D,    ctrl3dTb );
4566   createTool( SMESHOp::OpBareBorderVolume,      ctrl3dTb );
4567   createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4568   createTool( SMESHOp::OpEqualVolume,           ctrl3dTb );
4569
4570   createTool( SMESHOp::OpNode,              addElemTb );
4571   createTool( SMESHOp::OpElem0D,            addElemTb );
4572   createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4573   createTool( SMESHOp::OpBall,              addElemTb );
4574   createTool( SMESHOp::OpEdge,              addElemTb );
4575   createTool( SMESHOp::OpTriangle,          addElemTb );
4576   createTool( SMESHOp::OpQuadrangle,        addElemTb );
4577   createTool( SMESHOp::OpPolygon,           addElemTb );
4578   createTool( SMESHOp::OpTetrahedron,       addElemTb );
4579   createTool( SMESHOp::OpHexahedron,        addElemTb );
4580   createTool( SMESHOp::OpPentahedron,       addElemTb );
4581   createTool( SMESHOp::OpPyramid,           addElemTb );
4582   createTool( SMESHOp::OpHexagonalPrism,    addElemTb );
4583   createTool( SMESHOp::OpPolyhedron,        addElemTb );
4584
4585   createTool( SMESHOp::OpQuadraticEdge,          addNonElemTb );
4586   createTool( SMESHOp::OpQuadraticTriangle,      addNonElemTb );
4587   createTool( SMESHOp::OpBiQuadraticTriangle,    addNonElemTb );
4588   createTool( SMESHOp::OpQuadraticQuadrangle,    addNonElemTb );
4589   createTool( SMESHOp::OpBiQuadraticQuadrangle,  addNonElemTb );
4590   createTool( SMESHOp::OpQuadraticPolygon,       addNonElemTb );
4591   createTool( SMESHOp::OpQuadraticTetrahedron,   addNonElemTb );
4592   createTool( SMESHOp::OpQuadraticPyramid,       addNonElemTb );
4593   createTool( SMESHOp::OpQuadraticPentahedron,   addNonElemTb );
4594   createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4595   createTool( SMESHOp::OpQuadraticHexahedron,    addNonElemTb );
4596   createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4597
4598   createTool( SMESHOp::OpRemoveNodes,       remTb );
4599   createTool( SMESHOp::OpRemoveElements,    remTb );
4600   createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4601   createTool( SMESHOp::OpClearMesh,         remTb );
4602
4603   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
4604   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4605
4606   createTool( SMESHOp::OpMergeNodes,     transformTb );
4607   createTool( SMESHOp::OpMergeElements,  transformTb );
4608   createTool( SMESHOp::OpTranslation,    transformTb );
4609   createTool( SMESHOp::OpRotation,       transformTb );
4610   createTool( SMESHOp::OpSymmetry,       transformTb );
4611   createTool( SMESHOp::OpScale,          transformTb );
4612   createTool( SMESHOp::OpOffset,         transformTb );
4613   createTool( SMESHOp::OpSewing,         transformTb );
4614   createTool( SMESHOp::OpDuplicateNodes, transformTb );
4615
4616   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4617   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4618   createTool( SMESHOp::OpExtrusion,              modifyTb );
4619   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
4620   createTool( SMESHOp::OpRevolution,             modifyTb );
4621   createTool( SMESHOp::OpOrientation,            modifyTb );
4622   createTool( SMESHOp::OpReorientFaces,          modifyTb );
4623   createTool( SMESHOp::OpMoveNode,               modifyTb );
4624   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
4625   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
4626   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
4627   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
4628   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
4629   createTool( SMESHOp::OpSplitBiQuadratic,       modifyTb );
4630   createTool( SMESHOp::OpSmoothing,              modifyTb );
4631   createTool( SMESHOp::OpPatternMapping,         modifyTb );
4632
4633   createTool( SMESHOp::OpMinimumDistance, measuremTb );
4634
4635   createTool( SMESHOp::OpUpdate, dispModeTb );
4636
4637   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4638   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4639
4640   myRules.clear();
4641   QString
4642     OB      = "'ObjectBrowser'",
4643     View    = "'" + SVTK_Viewer::Type() + "'",
4644     pat     = "'%1'",
4645     mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4646     group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4647     hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4648     algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4649     smesh   = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4650     elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4651     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4652     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4653     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4654     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4655     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4656     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4657     subMesh      = elems,
4658     mesh_part    = mesh + " " + subMesh + " " + group,
4659     mesh_group   = mesh + " " + group,
4660     mesh_submesh = mesh + " " + subMesh,
4661     hyp_alg      = hypo + " " + algo;
4662
4663   // popup for object browser
4664   QString
4665     isInvisible("not( isVisible )"),
4666     isEmpty("numberOfNodes = 0"),
4667     isNotEmpty("numberOfNodes <> 0"),
4668
4669     // has nodes, edges, etc in VISIBLE! actor
4670     hasNodes("(numberOfNodes > 0 ) && hasActor"),
4671     hasElems("(count( elemTypes ) > 0)"),
4672     hasDifferentElems("(count( elemTypes ) > 1)"),
4673     hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4674     hasBalls("({'BallElem'} in elemTypes)"),
4675     hasElems0d("({'Elem0d'} in elemTypes)"),
4676     hasEdges("({'Edge'} in elemTypes)"),
4677     hasFaces("({'Face'} in elemTypes)"),
4678     hasVolumes("({'Volume'} in elemTypes)"),
4679     hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4680
4681   createPopupItem( SMESHOp::OpEditMesh,          OB, mesh, "&& selcount=1" );
4682   createPopupItem( SMESHOp::OpCreateSubMesh,     OB, mesh, "&& hasGeomReference");
4683   createPopupItem( SMESHOp::OpMeshOrder,         OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4684   createPopupItem( SMESHOp::OpEditSubMesh,       OB, subMesh, "&& selcount=1 && hasGeomReference" );
4685   createPopupItem( SMESHOp::OpEditGroup,         OB, group );
4686   createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4687
4688   popupMgr()->insert( separator(), -1, 0 );
4689   createPopupItem( SMESHOp::OpCompute,           OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4690   createPopupItem( SMESHOp::OpRecompute,         OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4691   createPopupItem( SMESHOp::OpShowErrors,        OB, mesh, "&& selcount=1 && hasErrors" );
4692   createPopupItem( SMESHOp::OpComputeSubMesh,    OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4693   createPopupItem( SMESHOp::OpPreCompute,        OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4694   createPopupItem( SMESHOp::OpEvaluate,          OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4695   popupMgr()->insert( separator(), -1, 0 );
4696   createPopupItem( SMESHOp::OpFileInformation,   OB, mesh, "&& selcount=1 && isImported" );
4697   createPopupItem( SMESHOp::OpMeshInformation,   OB, mesh_part );
4698   createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4699   createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4700   popupMgr()->insert( separator(), -1, 0 );
4701   createPopupItem( SMESHOp::OpCreateGroup,       OB, mesh, "&& selcount=1" );
4702   createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4703   createPopupItem( SMESHOp::OpConstructGroup,    OB, subMesh );
4704   popupMgr()->insert( separator(), -1, 0 );
4705   createPopupItem( SMESHOp::OpEditHypothesis,    OB, hypo, "&& isEditableHyp");
4706   createPopupItem( SMESHOp::OpUnassign,          OB, hyp_alg );
4707   popupMgr()->insert( separator(), -1, 0 );
4708   createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4709   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4710   //popupMgr()->insert( separator(), -1, 0 );
4711
4712   //popupMgr()->insert( separator(), -1, 0 );
4713
4714   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4715   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4716   QString only_one_2D        = only_one_non_empty + " && dim>1";
4717
4718   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4719   popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4720   createPopupItem( SMESHOp::OpPopupExportMED,  OB, mesh_group, multiple_non_empty, anId );
4721   createPopupItem( SMESHOp::OpPopupExportUNV,  OB, mesh_group, only_one_non_empty, anId );
4722   createPopupItem( SMESHOp::OpPopupExportSTL,  OB, mesh_group, only_one_2D, anId );
4723 #ifdef WITH_CGNS
4724   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4725 #endif
4726   createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4727   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, only_one_non_empty, anId );
4728   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, only_one_non_empty, anId );
4729
4730   anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 );        // IMPORT submenu
4731   createPopupItem( SMESHOp::OpPopupImportMED,  OB, smesh, "", anId );
4732   createPopupItem( SMESHOp::OpPopupImportUNV,  OB, smesh, "", anId );
4733   createPopupItem( SMESHOp::OpPopupImportSTL,  OB, smesh, "", anId );
4734 #ifdef WITH_CGNS
4735   createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4736 #endif
4737   createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4738   createPopupItem( SMESHOp::OpPopupImportGMF,  OB, smesh, "", anId );
4739   createPopupItem( SMESHOp::OpPopupImportDAT,  OB, smesh, "", anId );
4740   popupMgr()->insert( separator(), -1, 0 );
4741
4742   createPopupItem( SMESHOp::OpClearMesh,         OB, mesh );
4743   createPopupItem( SMESHOp::OpDelete,            OB, mesh_part + " " + hyp_alg );
4744   createPopupItem( SMESHOp::OpDeleteGroup,       OB, group );
4745
4746   // popup for viewer
4747   createPopupItem( SMESHOp::OpEditGroup,            View, group );
4748   createPopupItem( SMESHOp::OpAddElemGroupPopup,    View, elems, "&& guiState = 800" );
4749   createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4750
4751   popupMgr()->insert( separator(), -1, 0 );
4752   createPopupItem( SMESHOp::OpMeshInformation,    View, mesh_part );
4753   createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4754   createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4755   popupMgr()->insert( separator(), -1, 0 );
4756
4757   createPopupItem( SMESHOp::OpUpdate,           OB + " " + View, mesh_part );
4758   createPopupItem( SMESHOp::OpAutoColor,        OB + " " + View, mesh, "&& (not isAutoColor)" );
4759   createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4760   popupMgr()->insert( separator(), -1, 0 );
4761
4762   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4763   QString aType = QString( "%1type in {%2}" ).arg( lc );
4764   aType = aType.arg( mesh_part );
4765   QString aMeshInVTK = aClient + "&&" + aType;
4766
4767   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4768   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4769   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4770
4771   //-------------------------------------------------
4772   // Numbering
4773   //-------------------------------------------------
4774   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4775
4776   popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4777   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4778   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4779
4780   popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4781   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4782   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4783
4784   popupMgr()->insert( separator(), -1, -1 );
4785
4786   //-------------------------------------------------
4787   // Display Mode
4788   //-------------------------------------------------
4789   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4790
4791   popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4792   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4793   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4794
4795   popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4796   popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4797   popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4798
4799   popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4800   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4801   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4802
4803   popupMgr()->insert( separator(), anId, -1 );
4804
4805   popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4806   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4807   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4808
4809   //-------------------------------------------------
4810   // Display Entity
4811   //-------------------------------------------------
4812   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4813
4814   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4815
4816   popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4817   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4818   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4819
4820   popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4821   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4822   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4823
4824   popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4825   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4826   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4827
4828   popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4829   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4830   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4831
4832   popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4833   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4834   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4835
4836   popupMgr()->insert( separator(), anId, -1 );
4837
4838   popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4839   popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4840
4841   popupMgr()->insert( separator(), anId, -1 );
4842
4843   popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4844   popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4845
4846
4847   //-------------------------------------------------
4848   // Representation of the 2D Quadratic elements
4849   //-------------------------------------------------
4850   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4851   popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4852   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4853   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4854
4855   popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4856   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4857   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4858
4859   //-------------------------------------------------
4860   // Orientation of faces
4861   //-------------------------------------------------
4862   popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4863   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4864   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4865
4866   //-------------------------------------------------
4867   // Color / Size
4868   //-------------------------------------------------
4869   popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4870   popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4871
4872   //-------------------------------------------------
4873   // Transparency
4874   //-------------------------------------------------
4875   popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4876   popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4877
4878   //-------------------------------------------------
4879   // Controls
4880   //-------------------------------------------------
4881   QString
4882     aMeshInVtkHasNodes   = aMeshInVTK + "&&" + hasNodes,
4883     aMeshInVtkHasEdges   = aMeshInVTK + "&&" + hasEdges,
4884     aMeshInVtkHasFaces   = aMeshInVTK + "&&" + hasFaces,
4885     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4886
4887   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4888
4889   popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4890   popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4891
4892   popupMgr()->insert( separator(), anId, -1 );
4893
4894   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4895
4896   popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4897   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4898   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4899
4900   popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4901   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4902   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4903
4904   // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4905   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4906   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4907
4908   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4909
4910   popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4911   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4912   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4913
4914   popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4915   popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4916   popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4917
4918   popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4919   popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4920   popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4921   popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4922   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4923   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4924
4925   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4926
4927   popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4928   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4929   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4930
4931   popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4932   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4933                                        QtxPopupMgr::VisibleRule );
4934   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4935
4936   popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4937   popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4938   popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4939
4940   popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4941   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4942   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4943
4944   popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4945   popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4946   popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4947
4948   popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4949   popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4950   popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4951
4952   popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4953   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4954   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4955
4956   popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4957   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4958   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4959
4960   popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4961   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4962   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4963
4964   popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4965   popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4966   popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4967
4968   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4969   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4970   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4971
4972   popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4973   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4974   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4975
4976   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4977   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4978   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4979
4980   popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4981   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4982   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4983
4984   popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4985   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4986   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4987
4988   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4989
4990   popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D  ), aSubId, -1 );
4991   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4992   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4993
4994   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4995   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4996   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4997
4998   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4999   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5000   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5001
5002   popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5003   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5004   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5005
5006   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5007   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5008   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5009
5010   popupMgr()->insert ( action( SMESHOp::OpEqualVolume  ), aSubId, -1 );
5011   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5012   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5013
5014   popupMgr()->insert( separator(), anId, -1 );
5015
5016   popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5017   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5018   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5019   popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5020   popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5021
5022   popupMgr()->insert( separator(), anId, -1 );
5023
5024   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5025
5026   popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5027   popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5028
5029   popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5030   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5031   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5032
5033 #ifndef DISABLE_PLOT2DVIEWER
5034   popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5035   popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5036 #endif
5037
5038   //-------------------------------------------------
5039   // Show / Hide
5040   //-------------------------------------------------
5041   popupMgr()->insert( separator(), -1, -1 );
5042   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5043     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5044   popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5045   popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5046
5047   popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5048   popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5049
5050   popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5051   popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5052
5053   popupMgr()->insert( separator(), -1, -1 );
5054
5055   //-------------------------------------------------
5056   // Clipping
5057   //-------------------------------------------------
5058   popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5059   popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5060
5061   popupMgr()->insert( separator(), -1, -1 );
5062
5063   popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5064   popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5065   popupMgr()->insert( separator(), -1, -1 );
5066
5067   popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5068   popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5069
5070   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5071            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5072
5073   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5074            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5075 }
5076
5077 //================================================================================
5078 /*!
5079  * \brief Return true if SMESH or GEOM objects are selected.
5080  * Is called form LightApp_Module::activateModule() which clear selection if
5081  * not isSelectionCompatible()
5082  */
5083 //================================================================================
5084
5085 bool SMESHGUI::isSelectionCompatible()
5086 {
5087   bool isCompatible = true;
5088   SALOME_ListIO selected;
5089   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5090     Sel->selectedObjects( selected );
5091
5092   SALOME_ListIteratorOfListIO It( selected );
5093   for ( ; isCompatible && It.More(); It.Next())
5094     isCompatible =
5095       ( strcmp("GEOM",        It.Value()->getComponentDataType()) == 0 ) ||
5096       ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5097       ( strcmp("SMESH",       It.Value()->getComponentDataType()) == 0 );
5098
5099   return isCompatible;
5100 }
5101
5102
5103 bool SMESHGUI::reusableOperation( const int id )
5104 {
5105   // compute, evaluate and precompute are not reusable operations
5106   return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5107 }
5108
5109 namespace
5110 {
5111   QString wrap(const QString& text, const QString& tag)
5112   { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5113 }
5114
5115 bool SMESHGUI::activateModule( SUIT_Study* study )
5116 {
5117   bool res = SalomeApp_Module::activateModule( study );
5118
5119   setMenuShown( true );
5120   setToolShown( true );
5121
5122   // Fill in Help Panel
5123   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5124   app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5125
5126   int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5127   QString lab;
5128   QStringList items;
5129   lab =       tr("INFO_DEFINE_ALGOS") + "<br/>";
5130   lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5131   lab = lab + tr("INFO_COMPUTE") + "<br/>";
5132   lab = lab + tr("INFO_REFINE") + ":";
5133   items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5134         << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5135   lab = lab + wrap(items.join(""), "ul");
5136   items.clear();
5137
5138   app->infoPanel()->addLabel(lab, gb);
5139
5140   gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5141   items << wrap("UNV", "li")
5142         << wrap("MED", "li")
5143         << wrap("STL", "li")
5144         << wrap("CGNS", "li")
5145         << wrap("SAUV", "li")
5146         << wrap("GMF", "li");
5147   lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5148   items.clear();
5149
5150   app->infoPanel()->addLabel(lab, gb);
5151
5152   gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5153   lab = tr("INFO_DISPLAY") + "<br/>";
5154   items << wrap(tr("INFO_QUALITY_AREA"), "li")
5155         << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5156         << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5157         << wrap("...", "li");
5158   lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5159   items.clear();
5160   lab = lab + tr("INFO_CLIPPING");
5161
5162   app->infoPanel()->addLabel(lab, gb);
5163   // << Help Panel
5164
5165   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5166   PyGILState_STATE gstate = PyGILState_Ensure();
5167   PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5168   if ( !pluginsmanager ) {
5169     PyErr_Print();
5170   }
5171   else {
5172     PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5173     if ( !result )
5174       PyErr_Print();
5175     Py_XDECREF(result);
5176   }
5177   PyGILState_Release(gstate);
5178   // end of SMESH plugins loading
5179
5180   // Reset actions accelerator keys
5181   action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5182
5183   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5184   GetSMESHGen()->UpdateStudy();
5185
5186   // get all view currently opened in the study and connect their signals  to
5187   // the corresponding slots of the class.
5188   SUIT_Desktop* aDesk = study->application()->desktop();
5189   if ( aDesk ) {
5190     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5191     SUIT_ViewWindow* wnd;
5192     foreach ( wnd, wndList )
5193     {
5194       connectView( wnd );
5195
5196       // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5197       SMESH::UpdateActorsAfterUpdateStudy(wnd);
5198
5199       wnd->update();
5200     }
5201   }
5202
5203   Py_XDECREF(pluginsmanager);
5204   return res;
5205 }
5206
5207 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5208 {
5209   setMenuShown( false );
5210   setToolShown( false );
5211
5212   EmitSignalCloseAllDialogs();
5213
5214   // Unset actions accelerator keys
5215   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5216
5217   return SalomeApp_Module::deactivateModule( study );
5218 }
5219
5220 void SMESHGUI::studyClosed( SUIT_Study* s )
5221 {
5222   if( !s )
5223     return;
5224   SMESH::RemoveVisuData();
5225   SalomeApp_Module::studyClosed( s );
5226 }
5227
5228 void SMESHGUI::OnGUIEvent()
5229 {
5230   const QObject* obj = sender();
5231   if ( !obj || !obj->inherits( "QAction" ) )
5232     return;
5233   int id = actionId((QAction*)obj);
5234   if ( id != -1 )
5235     OnGUIEvent( id );
5236 }
5237
5238 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5239 {
5240   if ( CORBA::is_nil( myComponentSMESH ) )
5241   {
5242     SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5243     return aGUI.myComponentSMESH;
5244   }
5245   return myComponentSMESH;
5246 }
5247
5248 QString SMESHGUI::engineIOR() const
5249 {
5250   CORBA::ORB_var anORB = getApp()->orb();
5251   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5252   return QString( anIOR.in() );
5253 }
5254
5255 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5256 {
5257   SalomeApp_Module::contextMenuPopup( client, menu, title );
5258   SALOME_ListIO lst;
5259   selectionMgr()->selectedObjects( lst );
5260   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5261     Handle(SALOME_InteractiveObject) io = lst.First();
5262     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5263     _PTR(Study) study = appStudy->studyDS();
5264     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5265     if ( obj ) {
5266       QString aName = SMESH::fromUtf8( obj->GetName());
5267       while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5268         aName.remove(( aName.length() - 1 ), 1 );
5269       title = aName;
5270     }
5271   }
5272 }
5273
5274 LightApp_Selection* SMESHGUI::createSelection() const
5275 {
5276   return new SMESHGUI_Selection();
5277 }
5278
5279 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5280 {
5281   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5282   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5283   aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5284 #ifndef DISABLE_PYCONSOLE
5285   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5286 #endif
5287 }
5288
5289 void SMESHGUI::viewManagers( QStringList& list ) const
5290 {
5291   list.append( SVTK_Viewer::Type() );
5292 }
5293
5294 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5295 {
5296   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5297     SMESH::UpdateSelectionProp( this );
5298
5299     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5300     for(int i = 0; i < aViews.count() ; i++){
5301       SUIT_ViewWindow *sf = aViews[i];
5302       connectView( sf );
5303     }
5304     EmitSignalActivatedViewManager();
5305   }
5306 }
5307
5308 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5309 {
5310   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5311     myClippingPlaneInfoMap.erase( theViewManager );
5312 }
5313
5314 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5315 {
5316   theActor->AddObserver( SMESH::DeleteActorEvent,
5317                          myEventCallbackCommand.GetPointer(),
5318                          myPriority );
5319 }
5320
5321 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5322                               unsigned long theEvent,
5323                               void* theClientData,
5324                               void* /*theCallData*/ )
5325 {
5326   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5327     if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5328       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5329         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5330         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5331         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5332           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5333           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5334           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5335             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5336             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5337             SMESH::TActorList::iterator anIter3 = anActorList.begin();
5338             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5339               if( anActor == *anIter3 ) {
5340                 anActorList.erase( anIter3 );
5341                 break;
5342               }
5343             }
5344           }
5345         }
5346       }
5347     }
5348   }
5349 }
5350
5351 void SMESHGUI::createPreferences()
5352 {
5353   // General tab ------------------------------------------------------------------------
5354   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5355
5356   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5357   setPreferenceProperty( autoUpdate, "columns", 2 );
5358   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5359   setPreferenceProperty( lim, "min",  0 );
5360   setPreferenceProperty( lim, "max",  100000000 );
5361   setPreferenceProperty( lim, "step", 1000 );
5362   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5363   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5364
5365   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5366   setPreferenceProperty( dispgroup, "columns", 2 );
5367
5368   addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5369
5370   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5371   QStringList modes;
5372   modes.append( tr("MEN_WIRE") );
5373   modes.append( tr("MEN_SHADE") );
5374   modes.append( tr("MEN_NODES") );
5375   modes.append( tr("MEN_SHRINK") );
5376   QList<QVariant> indices;
5377   indices.append( 0 );
5378   indices.append( 1 );
5379   indices.append( 2 );
5380   indices.append( 3 );
5381   setPreferenceProperty( dispmode, "strings", modes );
5382   setPreferenceProperty( dispmode, "indexes", indices );
5383
5384   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5385   setPreferenceProperty( arcgroup, "columns", 2 );
5386   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5387   QStringList quadraticModes;
5388   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5389   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5390   indices.clear();
5391   indices.append( 0 );
5392   indices.append( 1 );
5393   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5394   setPreferenceProperty( quadraticmode, "indexes", indices );
5395
5396   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5397                               "SMESH", "max_angle" );
5398   setPreferenceProperty( maxAngle, "min", 1 );
5399   setPreferenceProperty( maxAngle, "max", 90 );
5400
5401   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5402   setPreferenceProperty( qaGroup, "columns", 2 );
5403   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5404   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5405   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5406   setPreferenceProperty( prec, "min", 0 );
5407   setPreferenceProperty( prec, "max", 100 );
5408   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5409   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5410   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5411   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5412   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5413
5414   /*
5415   int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5416   setPreferenceProperty( cinc, "min", 0 );
5417   setPreferenceProperty( cinc, "max", 5 );
5418   */
5419
5420   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5421   setPreferenceProperty( exportgroup, "columns", 2 );
5422   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5423   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5424   int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5425   setPreferenceProperty( zTol, "precision", 10 );
5426   setPreferenceProperty( zTol, "min", 0.0000000001 );
5427   setPreferenceProperty( zTol, "max", 1000000.0 );
5428   setPreferenceProperty( zTol, "step", 1. );
5429   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5430
5431   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5432   setPreferenceProperty( computeGroup, "columns", 2 );
5433   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5434   modes.clear();
5435   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5436   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5437   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5438   indices.clear();
5439   indices.append( 0 );
5440   indices.append( 1 );
5441   indices.append( 2 );
5442   setPreferenceProperty( notifyMode, "strings", modes );
5443   setPreferenceProperty( notifyMode, "indexes", indices );
5444
5445   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5446   setPreferenceProperty( infoGroup, "columns", 2 );
5447   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5448   modes.clear();
5449   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5450   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5451   indices.clear();
5452   indices.append( 0 );
5453   indices.append( 1 );
5454   setPreferenceProperty( elemInfo, "strings", modes );
5455   setPreferenceProperty( elemInfo, "indexes", indices );
5456   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5457   setPreferenceProperty( nodesLim, "min", 0 );
5458   setPreferenceProperty( nodesLim, "max", 10000000 );
5459   setPreferenceProperty( nodesLim, "step", 10000 );
5460   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5461   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5462   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5463   setPreferenceProperty( ctrlLim, "min", 0 );
5464   setPreferenceProperty( ctrlLim, "max", 10000000 );
5465   setPreferenceProperty( ctrlLim, "step", 1000 );
5466   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5467   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5468   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5469   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5470   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5471
5472   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5473   setPreferenceProperty( segGroup, "columns", 2 );
5474   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5475                               "SMESH", "segmentation" );
5476   setPreferenceProperty( segLen, "min", 1 );
5477   setPreferenceProperty( segLen, "max", 10000000 );
5478   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5479                              "SMESH", "nb_segments_per_edge" );
5480   setPreferenceProperty( nbSeg, "min", 1 );
5481   setPreferenceProperty( nbSeg, "max", 10000000 );
5482   addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5483
5484   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5485   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5486                  "SMESH", "forget_mesh_on_hyp_modif" );
5487
5488
5489   // Quantities with individual precision settings
5490   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5491   setPreferenceProperty( precGroup, "columns", 2 );
5492
5493   const int nbQuantities = 6;
5494   int precs[nbQuantities], ii = 0;
5495   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5496                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5497   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5498                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5499   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5500                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5501   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5502                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5503   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5504                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5505   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5506                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5507
5508   // Set property for precision value for spinboxes
5509   for ( ii = 0; ii < nbQuantities; ii++ ){
5510     setPreferenceProperty( precs[ii], "min", -14 );
5511     setPreferenceProperty( precs[ii], "max", 14 );
5512     setPreferenceProperty( precs[ii], "precision", 2 );
5513   }
5514
5515   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5516   setPreferenceProperty( previewGroup, "columns", 2 );
5517   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5518   setPreferenceProperty( chunkSize, "min",  1 );
5519   setPreferenceProperty( chunkSize, "max",  1000 );
5520   setPreferenceProperty( chunkSize, "step", 50 );
5521
5522   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5523   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5524
5525   // Mesh tab ------------------------------------------------------------------------
5526   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5527   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5528   setPreferenceProperty( nodeGroup, "columns", 3 );
5529
5530   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5531
5532   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5533
5534   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5535   QList<QVariant> aMarkerTypeIndicesList;
5536   QList<QVariant> aMarkerTypeIconsList;
5537   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5538     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5539     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5540     aMarkerTypeIndicesList << i;
5541     aMarkerTypeIconsList << pixmap;
5542   }
5543   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5544   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5545
5546   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5547
5548   QList<QVariant> aMarkerScaleIndicesList;
5549   QStringList     aMarkerScaleValuesList;
5550   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5551     aMarkerScaleIndicesList << i;
5552     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5553     aMarkerScaleValuesList  << QString::number( i );
5554   }
5555   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5556   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5557
5558   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5559   //setPreferenceProperty( elemGroup, "columns", 2 );
5560
5561   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5562   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5563   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5564   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5565   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5566   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5567   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5568   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5569   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5570
5571
5572   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5573   setPreferenceProperty( grpGroup, "columns", 2 );
5574
5575   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5576   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5577
5578   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5579                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5580   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5581                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5582   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5583                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5584   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5585                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5586   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5587                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5588   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5589                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5590   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5591                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5592
5593   setPreferenceProperty( size0d, "min", 1 );
5594   setPreferenceProperty( size0d, "max", 10 );
5595
5596  // setPreferenceProperty( ballSize, "min", 1 );
5597  // setPreferenceProperty( ballSize, "max", 10 );
5598
5599   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5600   setPreferenceProperty( ballDiameter, "max", 1e9 );
5601   setPreferenceProperty( ballDiameter, "step", 0.1 );
5602
5603   setPreferenceProperty( ballScale, "min", 1e-2 );
5604   setPreferenceProperty( ballScale, "max", 1e7 );
5605   setPreferenceProperty( ballScale, "step", 0.5 );
5606
5607   setPreferenceProperty( elemW, "min", 1 );
5608   setPreferenceProperty( elemW, "max", 5 );
5609
5610   setPreferenceProperty( outW, "min", 1 );
5611   setPreferenceProperty( outW, "max", 5 );
5612
5613   setPreferenceProperty( shrink, "min", 0 );
5614   setPreferenceProperty( shrink, "max", 100 );
5615
5616   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5617   setPreferenceProperty( numGroup, "columns", 2 );
5618
5619   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5620   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5621
5622   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5623   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5624
5625   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5626   setPreferenceProperty( orientGroup, "columns", 1 );
5627
5628   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5629   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5630
5631   setPreferenceProperty( orientScale, "min", 0.05 );
5632   setPreferenceProperty( orientScale, "max", 0.5 );
5633   setPreferenceProperty( orientScale, "step", 0.05 );
5634
5635   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5636
5637   // Selection tab ------------------------------------------------------------------------
5638   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5639
5640   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5641   setPreferenceProperty( selGroup, "columns", 2 );
5642
5643   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5644   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5645
5646   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5647   setPreferenceProperty( preGroup, "columns", 2 );
5648
5649   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5650
5651   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5652   setPreferenceProperty( precSelGroup, "columns", 2 );
5653
5654   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5655   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5656   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5657
5658   int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5659   setPreferenceProperty( sinc, "min", 0 );
5660   setPreferenceProperty( sinc, "max", 5 );
5661
5662   // Scalar Bar tab ------------------------------------------------------------------------
5663   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5664   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5665   setPreferenceProperty( fontGr, "columns", 2 );
5666
5667   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5668   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5669
5670   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5671   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5672
5673   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5674   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5675
5676   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5677   setPreferenceProperty( numcol, "min", 2 );
5678   setPreferenceProperty( numcol, "max", 256 );
5679
5680   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5681   setPreferenceProperty( numlab, "min", 2 );
5682   setPreferenceProperty( numlab, "max", 65 );
5683
5684   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5685   setPreferenceProperty( orientGr, "columns", 2 );
5686   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5687   QStringList orients;
5688   orients.append( tr( "SMESH_VERTICAL" ) );
5689   orients.append( tr( "SMESH_HORIZONTAL" ) );
5690   indices.clear(); indices.append( 0 ); indices.append( 1 );
5691   setPreferenceProperty( orient, "strings", orients );
5692   setPreferenceProperty( orient, "indexes", indices );
5693
5694   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5695   setPreferenceProperty( posVSizeGr, "columns", 2 );
5696   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5697   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5698   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5699   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5700   setPreferenceProperty( xv, "step", 0.1 );
5701   setPreferenceProperty( xv, "min", 0.0 );
5702   setPreferenceProperty( xv, "max", 1.0 );
5703   setPreferenceProperty( yv, "step", 0.1 );
5704   setPreferenceProperty( yv, "min", 0.0 );
5705   setPreferenceProperty( yv, "max", 1.0 );
5706   setPreferenceProperty( wv, "step", 0.1 );
5707   setPreferenceProperty( wv, "min", 0.0 );
5708   setPreferenceProperty( wv, "max", 1.0 );
5709   setPreferenceProperty( hv, "min", 0.0 );
5710   setPreferenceProperty( hv, "max", 1.0 );
5711   setPreferenceProperty( hv, "step", 0.1 );
5712
5713   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5714   setPreferenceProperty( posHSizeGr, "columns", 2 );
5715   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5716   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5717   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5718   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5719   setPreferenceProperty( xv, "min", 0.0 );
5720   setPreferenceProperty( xv, "max", 1.0 );
5721   setPreferenceProperty( xv, "step", 0.1 );
5722   setPreferenceProperty( xh, "min", 0.0 );
5723   setPreferenceProperty( xh, "max", 1.0 );
5724   setPreferenceProperty( xh, "step", 0.1 );
5725   setPreferenceProperty( yh, "min", 0.0 );
5726   setPreferenceProperty( yh, "max", 1.0 );
5727   setPreferenceProperty( yh, "step", 0.1 );
5728   setPreferenceProperty( wh, "min", 0.0 );
5729   setPreferenceProperty( wh, "max", 1.0 );
5730   setPreferenceProperty( wh, "step", 0.1 );
5731   setPreferenceProperty( hh, "min", 0.0 );
5732   setPreferenceProperty( hh, "max", 1.0 );
5733   setPreferenceProperty( hh, "step", 0.1 );
5734
5735   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5736   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5737   setPreferenceProperty( distributionGr, "columns", 3 );
5738   QStringList types;
5739   types.append( tr( "SMESH_MONOCOLOR" ) );
5740   types.append( tr( "SMESH_MULTICOLOR" ) );
5741   indices.clear(); indices.append( 0 ); indices.append( 1 );
5742   setPreferenceProperty( coloringType, "strings", types );
5743   setPreferenceProperty( coloringType, "indexes", indices );
5744   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5745
5746 }
5747
5748 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5749 {
5750   if ( sect=="SMESH" ) {
5751     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5752     float aTol = 1.00000009999999;
5753     std::string aWarning;
5754     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5755
5756     if ( name ==  "selection_object_color" ||
5757          name == "selection_element_color" ||
5758          name ==         "highlight_color" ||
5759          name == "selection_precision_node"    ||
5760          name == "selection_precision_element" ||
5761          name == "selection_precision_object"  ||
5762          name == "selection_increment")
5763     {
5764       SMESH::UpdateSelectionProp( this );
5765     }
5766     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5767     {
5768       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5769       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5770       if ( sbX1+sbW > aTol ) {
5771         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5772         sbX1 = 0.01;
5773         sbW  = 0.08;
5774         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5775         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5776       }
5777     }
5778     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5779     {
5780       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5781       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5782       if ( sbY1 + sbH > aTol ) {
5783         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5784         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5785         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5786       }
5787     }
5788     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5789     {
5790       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5791       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5792       if ( sbX1 + sbW > aTol ) {
5793         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5794         sbX1=0.1;
5795         sbW =0.08;
5796         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5797         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5798       }
5799     }
5800     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5801     {
5802       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5803       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5804       if ( sbY1 + sbH > aTol ) {
5805         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5806         sbY1=0.01;
5807         sbH =0.08;
5808         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5809         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5810       }
5811     }
5812     else if ( name == "segmentation" )
5813     {
5814       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5815       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5816     }
5817     else if ( name == "nb_segments_per_edge" )
5818     {
5819       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5820       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5821     }
5822     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5823     {
5824       QString val = aResourceMgr->stringValue( "SMESH", name );
5825       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5826     }
5827     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5828     {
5829       SMESH::UpdateFontProp( this );
5830     }
5831     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5832     {
5833       SMESH::UpdateFontProp( this );
5834     }
5835
5836     if ( aWarning.size() != 0 ) {
5837       aWarning += "The default values are applied instead.";
5838       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5839                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5840                                QObject::tr(aWarning.c_str()));
5841     }
5842   }
5843 }
5844
5845 //================================================================================
5846 /*!
5847  * \brief Update something in accordance with update flags
5848   * \param theFlags - update flags
5849 *
5850 * Update viewer or/and object browser etc. in accordance with update flags ( see
5851 * LightApp_UpdateFlags enumeration ).
5852 */
5853 //================================================================================
5854 void SMESHGUI::update( const int flags )
5855 {
5856   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5857     SMESH::UpdateView();
5858   else
5859     SalomeApp_Module::update( flags );
5860 }
5861
5862 //================================================================================
5863 /*!
5864  * \brief Set default selection mode
5865 *
5866 * SLOT called when operation committed. Sets default selection mode
5867 */
5868 //================================================================================
5869 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5870 {
5871   SVTK_ViewWindow* vtkWnd =
5872     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5873   if ( vtkWnd )
5874     vtkWnd->SetSelectionMode( ActorSelection );
5875 }
5876
5877 //================================================================================
5878 /*!
5879  * \brief Set default selection mode
5880 *
5881 * SLOT called when operation aborted. Sets default selection mode
5882 */
5883 //================================================================================
5884 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5885 {
5886   SVTK_ViewWindow* vtkWnd =
5887     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5888   if ( vtkWnd )
5889     vtkWnd->SetSelectionMode( ActorSelection );
5890 }
5891
5892 //================================================================================
5893 /*!
5894  * \brief Creates operation with given identifier
5895   * \param id - identifier of operation to be started
5896   * \return Pointer on created operation or NULL if operation is not created
5897 *
5898 * Virtual method redefined from the base class creates operation with given id.
5899 * It is called called automatically from startOperation method of base class.
5900 */
5901 //================================================================================
5902 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5903 {
5904   LightApp_Operation* op = 0;
5905   // to do : create operation here
5906   switch( id )
5907   {
5908   case SMESHOp::OpSplitBiQuadratic:
5909     op = new SMESHGUI_SplitBiQuadOp();
5910     break;
5911   case SMESHOp::OpConvertMeshToQuadratic:
5912     op = new SMESHGUI_ConvToQuadOp();
5913     break;
5914   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5915     op = new SMESHGUI_Make2DFrom3DOp();
5916     break;
5917   case SMESHOp::OpReorientFaces:
5918     op = new SMESHGUI_ReorientFacesOp();
5919     break;
5920   case SMESHOp::OpCreateMesh:
5921     op = new SMESHGUI_MeshOp( true, true );
5922     break;
5923   case SMESHOp::OpCreateSubMesh:
5924     op = new SMESHGUI_MeshOp( true, false );
5925     break;
5926   case SMESHOp::OpEditMeshOrSubMesh:
5927   case SMESHOp::OpEditMesh:
5928   case SMESHOp::OpEditSubMesh:
5929     op = new SMESHGUI_MeshOp( false );
5930     break;
5931   case SMESHOp::OpCompute:
5932   case SMESHOp::OpComputeSubMesh:
5933     op = new SMESHGUI_ComputeOp();
5934     break;
5935   case SMESHOp::OpShowErrors:
5936     op = new SMESHGUI_ShowErrorsOp();
5937     break;
5938   case SMESHOp::OpPreCompute:
5939     op = new SMESHGUI_PrecomputeOp();
5940     break;
5941   case SMESHOp::OpEvaluate:
5942     op = new SMESHGUI_EvaluateOp();
5943     break;
5944   case SMESHOp::OpMeshOrder:
5945     op = new SMESHGUI_MeshOrderOp();
5946     break;
5947   case SMESHOp::OpCreateGeometryGroup:
5948     op = new SMESHGUI_GroupOnShapeOp();
5949     break;
5950   case SMESHOp::OpFindElementByPoint:
5951     op = new SMESHGUI_FindElemByPointOp();
5952     break;
5953   case SMESHOp::OpMoveNode: // Make mesh pass through point
5954     op = new SMESHGUI_MakeNodeAtPointOp();
5955     break;
5956   case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5957     op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5958     break;
5959   default:
5960     break;
5961   }
5962
5963   if( !op )
5964     op = SalomeApp_Module::createOperation( id );
5965   return op;
5966 }
5967
5968 //================================================================================
5969 /*!
5970  * \brief Stops current operations and starts a given one
5971   * \param id - The id of the operation to start
5972  */
5973 //================================================================================
5974
5975 void SMESHGUI::switchToOperation(int id)
5976 {
5977   activeStudy()->abortAllOperations();
5978   startOperation( id );
5979 }
5980
5981 LightApp_Displayer* SMESHGUI::displayer()
5982 {
5983   if( !myDisplayer )
5984     myDisplayer = new SMESHGUI_Displayer( getApp() );
5985   return myDisplayer;
5986 }
5987
5988 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5989 {
5990   int aHue = -1;
5991   int aTolerance = 64;
5992   int anIterations = 0;
5993   int aPeriod = 5;
5994
5995   while( 1 )
5996   {
5997     anIterations++;
5998     if( anIterations % aPeriod == 0 )
5999     {
6000       aTolerance /= 2;
6001       if( aTolerance < 1 )
6002         break;
6003     }
6004
6005     aHue = (int)( 360.0 * rand() / RAND_MAX );
6006
6007     bool ok = true;
6008     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6009     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6010     for( ; it != itEnd; ++it )
6011     {
6012       SALOMEDS::Color anAutoColor = *it;
6013       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6014
6015       int h, s, v;
6016       aQColor.getHsv( &h, &s, &v );
6017       if( abs( h - aHue ) < aTolerance )
6018       {
6019         ok = false;
6020         break;
6021       }
6022     }
6023
6024     if( ok )
6025       break;
6026   }
6027
6028   QColor aColor;
6029   aColor.setHsv( aHue, 255, 255 );
6030
6031   SALOMEDS::Color aSColor;
6032   aSColor.R = aColor.redF();
6033   aSColor.G = aColor.greenF();
6034   aSColor.B = aColor.blueF();
6035
6036   return aSColor;
6037 }
6038
6039 const char* gSeparator = "_"; // character used to separate parameter names
6040 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6041 const char* gPathSep   = "|"; // character used to separate paths
6042
6043 /*!
6044  * \brief Store visual parameters
6045  *
6046  * This method is called just before the study document is saved.
6047  * Store visual parameters in AttributeParameter attribute(s)
6048  */
6049 void SMESHGUI::storeVisualParameters (int savePoint)
6050 {
6051   // localizing
6052   Kernel_Utils::Localizer loc;
6053
6054   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6055   if (!appStudy || !appStudy->studyDS())
6056     return;
6057   _PTR(Study) studyDS = appStudy->studyDS();
6058
6059   // componentName is used for encoding of entries when storing them in IParameters
6060   std::string componentName = myComponentSMESH->ComponentDataType();
6061   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6062   //if (!aSComponent) return;
6063
6064   // IParameters
6065   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6066                                                              componentName.c_str(),
6067                                                              savePoint);
6068   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6069
6070   // store custom markers
6071   if( !myMarkerMap.empty() )
6072   {
6073     VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6074     for( ; anIter != myMarkerMap.end(); anIter++ )
6075     {
6076       int anId = anIter->first;
6077       VTK::MarkerData aMarkerData = anIter->second;
6078       std::string aMarkerFileName = aMarkerData.first;
6079       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6080       if( aMarkerTexture.size() < 3 )
6081         continue; // should contain at least width, height and the first value
6082
6083       QString aPropertyName( "texture" );
6084       aPropertyName += gSeparator;
6085       aPropertyName += QString::number( anId );
6086
6087       QString aPropertyValue = aMarkerFileName.c_str();
6088       aPropertyValue += gPathSep;
6089
6090       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6091       ushort aWidth = *aTextureIter++;
6092       ushort aHeight = *aTextureIter++;
6093       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6094       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6095       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6096         aPropertyValue += QString::number( *aTextureIter );
6097
6098       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6099     }
6100   }
6101
6102   // viewers counters are used for storing view_numbers in IParameters
6103   int vtkViewers = 0;
6104
6105   // main cycle to store parameters of displayed objects
6106   QList<SUIT_ViewManager*> lst;
6107   QList<SUIT_ViewManager*>::Iterator it;
6108   getApp()->viewManagers(lst);
6109   for (it = lst.begin(); it != lst.end(); it++)
6110   {
6111     SUIT_ViewManager* vman = *it;
6112     QString vType = vman->getType();
6113
6114     // saving VTK actors properties
6115     if (vType == SVTK_Viewer::Type())
6116     {
6117       // store the clipping planes attached to the view manager
6118       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6119       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6120       if( anIter != myClippingPlaneInfoMap.end() )
6121         aClippingPlaneInfoList = anIter->second;
6122
6123       if( !aClippingPlaneInfoList.empty() ) {
6124         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6125         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6126         {
6127           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6128           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6129
6130           QString aPropertyName( "ClippingPlane" );
6131           aPropertyName += gSeparator;
6132           aPropertyName += QString::number( vtkViewers );
6133           aPropertyName += gSeparator;
6134           aPropertyName += QString::number( anId );
6135
6136           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6137           aPropertyValue += gDigitsSep;
6138           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6139           aPropertyValue += gDigitsSep;
6140           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6141             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6142             aPropertyValue += gDigitsSep;
6143             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6144             aPropertyValue += gDigitsSep;
6145             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6146             aPropertyValue += gDigitsSep;
6147             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6148             aPropertyValue += gDigitsSep;
6149             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6150             aPropertyValue += gDigitsSep;
6151             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6152             aPropertyValue += gDigitsSep;
6153             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6154           }
6155           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6156             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6157             aPropertyValue += gDigitsSep;
6158             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6159             aPropertyValue += gDigitsSep;
6160             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6161             aPropertyValue += gDigitsSep;
6162             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6163           }
6164
6165           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6166         }
6167       }
6168
6169       QVector<SUIT_ViewWindow*> views = vman->getViews();
6170       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6171       {
6172         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6173         {
6174           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6175           vtkActorCollection* allActors = aCopy.GetActors();
6176           allActors->InitTraversal();
6177           while (vtkActor* actor = allActors->GetNextActor())
6178           {
6179             if (actor->GetVisibility()) // store only visible actors
6180             {
6181               SMESH_Actor* aSmeshActor = 0;
6182               if (actor->IsA("SMESH_Actor"))
6183                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6184               if (aSmeshActor && aSmeshActor->hasIO())
6185               {
6186                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6187                 if (io->hasEntry())
6188                 {
6189                   // entry is "encoded" = it does NOT contain component address,
6190                   // since it is a subject to change on next component loading
6191                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6192
6193                   std::string param, vtkParam = vType.toLatin1().data();
6194                   vtkParam += gSeparator;
6195                   vtkParam += QString::number(vtkViewers).toLatin1().data();
6196                   vtkParam += gSeparator;
6197
6198                   // Visibility
6199                   param = vtkParam + "Visibility";
6200                   ip->setParameter(entry, param, "On");
6201
6202                   // Representation
6203                   param = vtkParam + "Representation";
6204                   ip->setParameter(entry, param, QString::number
6205                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6206
6207                   // IsShrunk
6208                   param = vtkParam + "IsShrunk";
6209                   ip->setParameter(entry, param, QString::number
6210                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6211
6212                   // Displayed entities
6213                   unsigned int aMode = aSmeshActor->GetEntityMode();
6214                   bool isE  = aMode & SMESH_Actor::eEdges;
6215                   bool isF  = aMode & SMESH_Actor::eFaces;
6216                   bool isV  = aMode & SMESH_Actor::eVolumes;
6217                   bool is0d = aMode & SMESH_Actor::e0DElements;
6218                   bool isB  = aMode & SMESH_Actor::eBallElem;
6219
6220                   QString modeStr ("e");
6221                   modeStr += gDigitsSep; modeStr += QString::number(isE);
6222                   modeStr += gDigitsSep; modeStr += "f";
6223                   modeStr += gDigitsSep; modeStr += QString::number(isF);
6224                   modeStr += gDigitsSep; modeStr += "v";
6225                   modeStr += gDigitsSep; modeStr += QString::number(isV);
6226                   modeStr += gDigitsSep; modeStr += "0d";
6227                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
6228                   modeStr += gDigitsSep; modeStr += "b";
6229                   modeStr += gDigitsSep; modeStr += QString::number(isB);
6230
6231                   param = vtkParam + "Entities";
6232                   ip->setParameter(entry, param, modeStr.toLatin1().data());
6233
6234                   // Colors
6235                   double r, g, b;
6236                   int delta;
6237
6238                   aSmeshActor->GetSufaceColor(r, g, b, delta);
6239                   QStringList colorStr;
6240                   colorStr << "surface";
6241                   colorStr << QString::number(r);
6242                   colorStr << QString::number(g);
6243                   colorStr << QString::number(b);
6244
6245                   colorStr << "backsurface";
6246                   colorStr << QString::number(delta);
6247
6248                   aSmeshActor->GetVolumeColor(r, g, b, delta);
6249                   colorStr << "volume";
6250                   colorStr << QString::number(r);
6251                   colorStr << QString::number(g);
6252                   colorStr << QString::number(b);
6253                   colorStr << QString::number(delta);
6254
6255                   aSmeshActor->GetEdgeColor(r, g, b);
6256                   colorStr << "edge";
6257                   colorStr << QString::number(r);
6258                   colorStr << QString::number(g);
6259                   colorStr << QString::number(b);
6260
6261                   aSmeshActor->GetNodeColor(r, g, b);
6262                   colorStr << "node";
6263                   colorStr << QString::number(r);
6264                   colorStr << QString::number(g);
6265                   colorStr << QString::number(b);
6266
6267                   aSmeshActor->GetOutlineColor(r, g, b);
6268                   colorStr << "outline";
6269                   colorStr << QString::number(r);
6270                   colorStr << QString::number(g);
6271                   colorStr << QString::number(b);
6272
6273                   aSmeshActor->Get0DColor(r, g, b);
6274                   colorStr << "elem0d";
6275                   colorStr << QString::number(r);
6276                   colorStr << QString::number(g);
6277                   colorStr << QString::number(b);
6278
6279                   aSmeshActor->GetBallColor(r, g, b);
6280                   colorStr << "ball";
6281                   colorStr << QString::number(r);
6282                   colorStr << QString::number(g);
6283                   colorStr << QString::number(b);
6284
6285                   aSmeshActor->GetFacesOrientationColor(r, g, b);
6286                   colorStr << "orientation";
6287                   colorStr << QString::number(r);
6288                   colorStr << QString::number(g);
6289                   colorStr << QString::number(b);
6290
6291                   param = vtkParam + "Colors";
6292                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6293
6294                   // Sizes
6295                   QStringList sizeStr;
6296                   sizeStr << "line";
6297                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6298                   sizeStr << "outline";
6299                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6300                   sizeStr << "elem0d";
6301                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6302                   sizeStr << "ball";
6303                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6304                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6305                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6306                   sizeStr << "shrink";
6307                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6308                   sizeStr << "orientation";
6309                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6310                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6311
6312                   param = vtkParam + "Sizes";
6313                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6314
6315                   // Point marker
6316                   QString markerStr;
6317
6318                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6319                   if( aMarkerType == VTK::MT_USER ) {
6320                     markerStr += "custom";
6321                     markerStr += gDigitsSep;
6322                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6323                   }
6324                   else {
6325                     markerStr += "std";
6326                     markerStr += gDigitsSep;
6327                     markerStr += QString::number( (int)aMarkerType );
6328                     markerStr += gDigitsSep;
6329                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6330                   }
6331
6332                   param = vtkParam + "PointMarker";
6333                   ip->setParameter(entry, param, markerStr.toLatin1().data());
6334
6335                   // Opacity
6336                   param = vtkParam + "Opacity";
6337                   ip->setParameter(entry, param,
6338                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6339
6340                   // Clipping
6341                   param = vtkParam + "ClippingPlane";
6342                   int aPlaneId = 0;
6343                   if( !aClippingPlaneInfoList.empty() ) {
6344                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6345                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6346                     {
6347                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6348                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6349                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
6350                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6351                         if( aSmeshActor == *anIter2 ) {
6352                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6353                                             QString::number( anId ).toLatin1().constData() );
6354                           break;
6355                         }
6356                       }
6357                     }
6358                   }
6359                   if( aPlaneId == 0 )
6360                     ip->setParameter( entry, param, "Off" );
6361                 } // if (io->hasEntry())
6362               } // SMESH_Actor && hasIO
6363             } // isVisible
6364           } // while.. actors traversal
6365         } // if (vtkView)
6366       } // for (views)
6367       vtkViewers++;
6368     } // if (SVTK view model)
6369   } // for (viewManagers)
6370 }
6371
6372 // data structures for clipping planes processing
6373 typedef struct {
6374   int Id;
6375   int Mode;
6376   bool isOpenGLClipping;
6377   vtkIdType RelativeOrientation;
6378   double Distance;
6379   double Angle[2];
6380   int AbsoluteOrientation;
6381   double X, Y, Z, Dx, Dy, Dz;
6382 } TPlaneData;
6383 typedef std::list<TPlaneData>         TPlaneDataList;
6384 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6385
6386 typedef std::list<vtkActor*>          TActorList;
6387 typedef struct {
6388   int PlaneId;
6389   TActorList ActorList;
6390   SUIT_ViewManager* ViewManager;
6391 } TPlaneInfo;
6392 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6393 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6394
6395 /*!
6396  * \brief Restore visual parameters
6397  *
6398  * This method is called after the study document is opened.
6399  * Restore visual parameters from AttributeParameter attribute(s)
6400  */
6401 void SMESHGUI::restoreVisualParameters (int savePoint)
6402 {
6403   // localizing
6404   Kernel_Utils::Localizer loc;
6405
6406   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6407   if (!appStudy || !appStudy->studyDS())
6408     return;
6409   _PTR(Study) studyDS = appStudy->studyDS();
6410
6411   // componentName is used for encoding of entries when storing them in IParameters
6412   std::string componentName = myComponentSMESH->ComponentDataType();
6413
6414   // IParameters
6415   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6416                                                              componentName.c_str(),
6417                                                              savePoint);
6418   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6419
6420   // restore custom markers and map of clipping planes
6421   TPlaneDataMap aPlaneDataMap;
6422
6423   std::vector<std::string> properties = ip->getProperties();
6424   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6425   {
6426     std::string property = *propIt;
6427     QString aPropertyName( property.c_str() );
6428     QString aPropertyValue( ip->getProperty( property ).c_str() );
6429
6430     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6431     if( aPropertyNameList.isEmpty() )
6432       continue;
6433
6434     QString aPropertyType = aPropertyNameList[0];
6435     if( aPropertyType == "texture" )
6436     {
6437       if( aPropertyNameList.size() != 2 )
6438         continue;
6439
6440       bool ok = false;
6441       int anId = aPropertyNameList[1].toInt( &ok );
6442       if( !ok || anId < 1 )
6443         continue;
6444
6445       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6446       if( aPropertyValueList.size() != 2 )
6447         continue;
6448
6449       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6450       QString aMarkerTextureString = aPropertyValueList[1];
6451       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6452       if( aMarkerTextureStringList.size() != 3 )
6453         continue;
6454
6455       ok = false;
6456       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6457       if( !ok )
6458         continue;
6459
6460       ok = false;
6461       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6462       if( !ok )
6463         continue;
6464
6465       VTK::MarkerTexture aMarkerTexture;
6466       aMarkerTexture.push_back( aWidth );
6467       aMarkerTexture.push_back( aHeight );
6468
6469       QString aMarkerTextureData = aMarkerTextureStringList[2];
6470       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6471       {
6472         QChar aChar = aMarkerTextureData.at( i );
6473         if( aChar.isDigit() )
6474           aMarkerTexture.push_back( aChar.digitValue() );
6475       }
6476
6477       myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6478     }
6479     else if( aPropertyType == "ClippingPlane" )
6480     {
6481       if( aPropertyNameList.size() != 3 )
6482         continue;
6483
6484       bool ok = false;
6485       int aViewId = aPropertyNameList[1].toInt( &ok );
6486       if( !ok || aViewId < 0 )
6487         continue;
6488
6489       ok = false;
6490       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6491       if( !ok || aClippingPlaneId < 0 )
6492         continue;
6493
6494       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6495       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6496         continue;
6497
6498       TPlaneData aPlaneData;
6499       aPlaneData.AbsoluteOrientation = false;
6500       aPlaneData.RelativeOrientation = 0;
6501       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6502       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6503       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6504
6505       aPlaneData.Id = aClippingPlaneId;
6506
6507       ok = false;
6508       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6509       if( !ok )
6510         continue;
6511
6512       ok = false;
6513       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6514       if( !ok )
6515         continue;
6516
6517       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6518       {
6519         ok = false;
6520         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6521         if( !ok )
6522           continue;
6523
6524         ok = false;
6525         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6526         if( !ok )
6527           continue;
6528
6529         ok = false;
6530         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6531         if( !ok )
6532           continue;
6533
6534         ok = false;
6535         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6536         if( !ok )
6537           continue;
6538
6539         ok = false;
6540         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6541         if( !ok )
6542           continue;
6543
6544         ok = false;
6545         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6546         if( !ok )
6547           continue;
6548
6549         ok = false;
6550         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6551         if( !ok )
6552           continue;
6553       }
6554       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6555         ok = false;
6556         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6557         if( !ok )
6558           continue;
6559
6560         ok = false;
6561         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6562         if( !ok )
6563           continue;
6564
6565         ok = false;
6566         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6567         if( !ok )
6568           continue;
6569
6570         ok = false;
6571         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6572         if( !ok )
6573           continue;
6574       }
6575
6576       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6577       aPlaneDataList.push_back( aPlaneData );
6578     }
6579   }
6580
6581   TPlaneInfoMap aPlaneInfoMap;
6582
6583   std::vector<std::string> entries = ip->getEntries();
6584
6585   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6586   {
6587     // entry is a normal entry - it should be "decoded" (setting base address of component)
6588     QString entry (ip->decodeEntry(*entIt).c_str());
6589
6590     // Check that the entry corresponds to a real object in the Study
6591     // as the object may be deleted or modified after the visual state is saved.
6592     _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6593     if (!so) continue; //Skip the not existent entry
6594
6595     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6596     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6597
6598     std::vector<std::string>::iterator namesIt = paramNames.begin();
6599     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6600
6601     // actors are stored in a map after displaying of them for
6602     // quicker access in the future: map < viewID to actor >
6603     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6604
6605     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6606     {
6607       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6608       // '_' is used as separator and should not be used in viewer type or parameter names.
6609       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6610       if (lst.size() != 3)
6611         continue;
6612
6613       QString viewerTypStr = lst[0];
6614       QString viewIndexStr = lst[1];
6615       QString paramNameStr = lst[2];
6616
6617       bool ok;
6618       int viewIndex = viewIndexStr.toUInt(&ok);
6619       if (!ok) // bad conversion of view index to integer
6620         continue;
6621
6622       // viewers
6623       if (viewerTypStr == SVTK_Viewer::Type())
6624       {
6625         SMESH_Actor* aSmeshActor = 0;
6626         if (vtkActors.IsBound(viewIndex))
6627           aSmeshActor = vtkActors.Find(viewIndex);
6628
6629         QList<SUIT_ViewManager*> lst;
6630         getApp()->viewManagers(viewerTypStr, lst);
6631
6632         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6633         SUIT_ViewManager* vman = NULL;
6634         if (viewIndex >= 0 && viewIndex < lst.count())
6635           vman = lst.at(viewIndex);
6636
6637         if (paramNameStr == "Visibility")
6638         {
6639           if (!aSmeshActor && displayer() && vman)
6640           {
6641             SUIT_ViewModel* vmodel = vman->getViewModel();
6642             // SVTK view model can be casted to SALOME_View
6643             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6644
6645             // store displayed actor in a temporary map for quicker
6646             // access later when restoring other parameters
6647             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6648             vtkRenderer* Renderer = vtkView->getRenderer();
6649             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6650             vtkActorCollection* theActors = aCopy.GetActors();
6651             theActors->InitTraversal();
6652             bool isFound = false;
6653             vtkActor *ac = theActors->GetNextActor();
6654             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6655               if (ac->IsA("SMESH_Actor")) {
6656                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6657                 if (aGeomAc->hasIO()) {
6658                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6659                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6660                     isFound = true;
6661                     vtkActors.Bind(viewIndex, aGeomAc);
6662                   }
6663                 }
6664               }
6665             }
6666           }
6667         } // if (paramNameStr == "Visibility")
6668         else
6669         {
6670           // the rest properties "work" with SMESH_Actor
6671           if (aSmeshActor)
6672           {
6673             QString val ((*valuesIt).c_str());
6674
6675             // Representation
6676             if (paramNameStr == "Representation") {
6677               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6678             }
6679             // IsShrunk
6680             else if (paramNameStr == "IsShrunk") {
6681               if (val.toInt()) {
6682                 if (!aSmeshActor->IsShrunk())
6683                   aSmeshActor->SetShrink();
6684               }
6685               else {
6686                 if (aSmeshActor->IsShrunk())
6687                   aSmeshActor->UnShrink();
6688               }
6689             }
6690             // Displayed entities
6691             else if (paramNameStr == "Entities") {
6692               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6693               int aEntityMode = SMESH_Actor::eAllEntity;
6694               for ( int i = 0; i < mode.count(); i+=2 ) {
6695                 if ( i < mode.count()-1 ) {
6696                   QString type = mode[i];
6697                   bool val = mode[i+1].toInt();
6698                   if      ( type == "e" && !val )
6699                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6700                   else if ( type == "f" && !val )
6701                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6702                   else if ( type == "v" && !val )
6703                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6704                   else if ( type == "0d" && !val )
6705                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6706                   else if ( type == "b" && !val )
6707                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6708                 }
6709               }
6710               aSmeshActor->SetEntityMode( aEntityMode );
6711             }
6712             // Colors
6713             else if (paramNameStr == "Colors") {
6714               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6715               QColor nodeColor;
6716               QColor edgeColor;
6717               QColor faceColor;
6718               QColor volumeColor;
6719               QColor elem0dColor;
6720               QColor ballColor;
6721               QColor outlineColor;
6722               QColor orientationColor;
6723               int deltaF;
6724               int deltaV;
6725               QColor c;
6726               double r, g, b;
6727               bool bOk;
6728               // below lines are required to get default values for delta coefficients
6729               // of backface color for faces and color of reversed volumes
6730               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6731               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6732               for ( int i = 0; i < colors.count(); i++ ) {
6733                 QString type = colors[i];
6734                 if ( type == "surface" ) {
6735                   // face color is set by 3 values r:g:b, where
6736                   // - r,g,b - is rgb color components
6737                   if ( i+1 >= colors.count() ) break;                  // format error
6738                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6739                   if ( i+2 >= colors.count() ) break;                  // format error
6740                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6741                   if ( i+3 >= colors.count() ) break;                  // format error
6742                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6743                   faceColor.setRgbF( r, g, b );
6744                   i += 3;
6745                 }
6746                 else if ( type == "backsurface" ) {
6747                   // backface color can be defined in several ways
6748                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6749                   // - in latest versions, it is set as delta coefficient
6750                   bool rgbOk = false, deltaOk;
6751                   if ( i+1 >= colors.count() ) break;                  // format error
6752                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6753                   int delta = colors[i+1].toInt( &deltaOk );
6754                   i++;                                 // shift index
6755                   if ( i+1 < colors.count() )          // index is shifted to 1
6756                     g = colors[i+1].toDouble( &rgbOk );
6757                   if ( rgbOk ) i++;                    // shift index
6758                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6759                     b = colors[i+1].toDouble( &rgbOk );
6760                   if ( rgbOk ) i++;
6761                   // - as currently there's no way to set directly backsurface color as it was before,
6762                   // we ignore old dump where r,g,b triple was set
6763                   // - also we check that delta parameter is set properly
6764                   if ( !rgbOk && deltaOk )
6765                     deltaF = delta;
6766                 }
6767                 else if ( type == "volume" ) {
6768                   // volume color is set by 4 values r:g:b:delta, where
6769                   // - r,g,b - is a normal volume rgb color components
6770                   // - delta - is a reversed volume color delta coefficient
6771                   if ( i+1 >= colors.count() ) break;                  // format error
6772                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6773                   if ( i+2 >= colors.count() ) break;                  // format error
6774                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6775                   if ( i+3 >= colors.count() ) break;                  // format error
6776                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6777                   if ( i+4 >= colors.count() ) break;                  // format error
6778                   int delta = colors[i+4].toInt( &bOk );
6779                   if ( !bOk ) break;                                   // format error
6780                   volumeColor.setRgbF( r, g, b );
6781                   deltaV = delta;
6782                   i += 4;
6783                 }
6784                 else if ( type == "edge" ) {
6785                   // edge color is set by 3 values r:g:b, where
6786                   // - r,g,b - is rgb color components
6787                   if ( i+1 >= colors.count() ) break;                  // format error
6788                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6789                   if ( i+2 >= colors.count() ) break;                  // format error
6790                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6791                   if ( i+3 >= colors.count() ) break;                  // format error
6792                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6793                   edgeColor.setRgbF( r, g, b );
6794                   i += 3;
6795                 }
6796                 else if ( type == "node" ) {
6797                   // node color is set by 3 values r:g:b, where
6798                   // - r,g,b - is rgb color components
6799                   if ( i+1 >= colors.count() ) break;                  // format error
6800                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6801                   if ( i+2 >= colors.count() ) break;                  // format error
6802                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6803                   if ( i+3 >= colors.count() ) break;                  // format error
6804                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6805                   nodeColor.setRgbF( r, g, b );
6806                   i += 3;
6807                 }
6808                 else if ( type == "elem0d" ) {
6809                   // 0d element 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                   elem0dColor.setRgbF( r, g, b );
6818                   i += 3;
6819                 }
6820                 else if ( type == "ball" ) {
6821                   // ball color is set by 3 values r:g:b, where
6822                   // - r,g,b - is rgb color components
6823                   if ( i+1 >= colors.count() ) break;                  // format error
6824                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6825                   if ( i+2 >= colors.count() ) break;                  // format error
6826                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6827                   if ( i+3 >= colors.count() ) break;                  // format error
6828                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6829                   ballColor.setRgbF( r, g, b );
6830                   i += 3;
6831                 }
6832                 else if ( type == "outline" ) {
6833                   // outline color is set by 3 values r:g:b, where
6834                   // - r,g,b - is rgb color components
6835                   if ( i+1 >= colors.count() ) break;                  // format error
6836                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6837                   if ( i+2 >= colors.count() ) break;                  // format error
6838                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6839                   if ( i+3 >= colors.count() ) break;                  // format error
6840                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6841                   outlineColor.setRgbF( r, g, b );
6842                   i += 3;
6843                 }
6844                 else if ( type == "orientation" ) {
6845                   // orientation color is set by 3 values r:g:b, where
6846                   // - r,g,b - is rgb color components
6847                   if ( i+1 >= colors.count() ) break;                  // format error
6848                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6849                   if ( i+2 >= colors.count() ) break;                  // format error
6850                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6851                   if ( i+3 >= colors.count() ) break;                  // format error
6852                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6853                   orientationColor.setRgbF( r, g, b );
6854                   i += 3;
6855                 }
6856               }
6857               // node color
6858               if ( nodeColor.isValid() )
6859                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6860               // edge color
6861               if ( edgeColor.isValid() )
6862                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6863               // face color
6864               if ( faceColor.isValid() )
6865                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6866               // volume color
6867               if ( volumeColor.isValid() )
6868                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6869               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6870                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6871               // 0d element color
6872               if ( elem0dColor.isValid() )
6873                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6874               // ball color
6875               if ( ballColor.isValid() )
6876                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6877               // outline color
6878               if ( outlineColor.isValid() )
6879                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6880               // orientation color
6881               if ( orientationColor.isValid() )
6882                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6883             }
6884             // Sizes
6885             else if (paramNameStr == "Sizes") {
6886               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6887               bool bOk;
6888               int lineWidth = -1;
6889               int outlineWidth = -1;
6890               int elem0dSize = -1;
6891               //int ballSize = -1;
6892               double ballDiameter = -1.0;
6893               double ballScale = -1.0;
6894               double shrinkSize = -1;
6895               double orientationSize = -1;
6896               bool orientation3d = false;
6897               for ( int i = 0; i < sizes.count(); i++ ) {
6898                 QString type = sizes[i];
6899                 if ( type == "line" ) {
6900                   // line (wireframe) width is given as single integer value
6901                   if ( i+1 >= sizes.count() ) break;                    // format error
6902                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6903                   lineWidth = v;
6904                   i++;
6905                 }
6906                 if ( type == "outline" ) {
6907                   // outline width is given as single integer value
6908                   if ( i+1 >= sizes.count() ) break;                    // format error
6909                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6910                   outlineWidth = v;
6911                   i++;
6912                 }
6913                 else if ( type == "elem0d" ) {
6914                   // 0d element size is given as single integer value
6915                   if ( i+1 >= sizes.count() ) break;                    // format error
6916                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6917                   elem0dSize = v;
6918                   i++;
6919                 }
6920                 else if ( type == "ball" ) {
6921                   // balls are specified by two values: size:scale, where
6922                   // - size - is a integer value specifying size
6923                   // - scale - is a double value specifying scale factor
6924                   if ( i+1 >= sizes.count() ) break;                       // format error
6925                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6926                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6927                   if ( i+2 >= sizes.count() ) break;                       // format error
6928                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6929                   //ballSize = v1;
6930                   ballDiameter = v1;
6931                   ballScale = v2;
6932                   i += 2;
6933                 }
6934                 else if ( type == "shrink" ) {
6935                   // shrink factor is given as single floating point value
6936                   if ( i+1 >= sizes.count() ) break;                          // format error
6937                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6938                   shrinkSize = v;
6939                   i++;
6940                 }
6941                 else if ( type == "orientation" ) {
6942                   // orientation vectors are specified by two values size:3d, where
6943                   // - size - is a floating point value specifying scale factor
6944                   // - 3d - is a boolean
6945                   if ( i+1 >= sizes.count() ) break;                          // format error
6946                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6947                   if ( i+2 >= sizes.count() ) break;                          // format error
6948                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6949                   orientationSize = v1;
6950                   orientation3d = (bool)v2;
6951                   i += 2;
6952                 }
6953               }
6954               // line (wireframe) width
6955               if ( lineWidth > 0 )
6956                 aSmeshActor->SetLineWidth( lineWidth );
6957               // outline width
6958               if ( outlineWidth > 0 )
6959                 aSmeshActor->SetOutlineWidth( outlineWidth );
6960               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6961                 aSmeshActor->SetOutlineWidth( lineWidth );
6962               // 0d element size
6963               if ( elem0dSize > 0 )
6964                 aSmeshActor->Set0DSize( elem0dSize );
6965               // ball size
6966               /*if ( ballSize > 0 )
6967                 aSmeshActor->SetBallSize( ballSize );*/
6968               // ball diameter
6969               if ( ballDiameter > 0 )
6970                 aSmeshActor->SetBallSize( ballDiameter );
6971               // ball scale
6972               if ( ballScale > 0.0 )
6973                 aSmeshActor->SetBallScale( ballScale );
6974               // shrink factor
6975               if ( shrinkSize > 0 )
6976                 aSmeshActor->SetShrinkFactor( shrinkSize );
6977               // orientation vectors
6978               if ( orientationSize > 0 ) {
6979                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6980                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6981               }
6982             }
6983             // Point marker
6984             else if (paramNameStr == "PointMarker") {
6985               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6986               if( data.count() >= 2 ) {
6987                 bool ok = false;
6988                 int aParam1 = data[1].toInt( &ok );
6989                 if( ok ) {
6990                   if( data[0] == "std" && data.count() == 3 ) {
6991                     int aParam2 = data[2].toInt( &ok );
6992                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6993                   }
6994                   else if( data[0] == "custom" ) {
6995                     VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6996                     if( markerIt != myMarkerMap.end() ) {
6997                       VTK::MarkerData aMarkerData = markerIt->second;
6998                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6999                     }
7000                   }
7001                 }
7002               }
7003             }
7004             // Opacity
7005             else if (paramNameStr == "Opacity") {
7006               aSmeshActor->SetOpacity(val.toFloat());
7007             }
7008             // Clipping
7009             else if (paramNameStr.startsWith("ClippingPlane")) {
7010               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7011               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7012               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7013               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7014               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7015               // new format - val looks like "Off" or "0" (plane id)
7016               // (note: in new format "Off" value is used only for consistency,
7017               //  so it is processed together with values in old format)
7018               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7019               if( anIsOldFormat ) {
7020                 if (paramNameStr == "ClippingPlane1" || val == "Off")
7021                   aSmeshActor->RemoveAllClippingPlanes();
7022                 if (val != "Off") {
7023                   QList<SUIT_ViewManager*> lst;
7024                   getApp()->viewManagers(viewerTypStr, lst);
7025                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7026                   if (viewIndex >= 0 && viewIndex < lst.count()) {
7027                     SUIT_ViewManager* vman = lst.at(viewIndex);
7028                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7029
7030                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7031
7032                     SMESH::TActorList anActorList;
7033                     anActorList.push_back( aSmeshActor );
7034                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7035                     aPlane->myViewWindow = vtkView;
7036                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7037                     aPlane->PlaneMode = aMode;
7038                     bool isOpenGLClipping = ( bool )vals[1].toInt();
7039                     aPlane->IsOpenGLClipping = isOpenGLClipping;
7040                     if ( aMode == SMESH::Absolute ) {
7041                       aPlane->myAbsoluteOrientation = vals[2].toInt();
7042                       aPlane->X = vals[3].toFloat();
7043                       aPlane->Y = vals[4].toFloat();
7044                       aPlane->Z = vals[5].toFloat();
7045                       aPlane->Dx = vals[6].toFloat();
7046                       aPlane->Dy = vals[7].toFloat();
7047                       aPlane->Dz = vals[8].toFloat();
7048                     }
7049                     else if ( aMode == SMESH::Relative ) {
7050                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7051                       aPlane->myDistance = vals[3].toFloat();
7052                       aPlane->myAngle[0] = vals[4].toFloat();
7053                       aPlane->myAngle[1] = vals[5].toFloat();
7054                     }
7055
7056                     if( aPlane ) {
7057                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7058                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7059                         aClippingPlaneInfo.Plane = aPlane;
7060                         aClippingPlaneInfo.ActorList = anActorList;
7061                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7062                       }
7063                     }
7064                   }
7065                 }
7066               }
7067               else {
7068                 bool ok = false;
7069                 int aPlaneId = val.toInt( &ok );
7070                 if( ok && aPlaneId >= 0 ) {
7071                   bool anIsDefinedPlane = false;
7072                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7073                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7074                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7075                     TPlaneInfo& aPlaneInfo = *anIter;
7076                     if( aPlaneInfo.PlaneId == aPlaneId ) {
7077                       aPlaneInfo.ActorList.push_back( aSmeshActor );
7078                       anIsDefinedPlane = true;
7079                       break;
7080                     }
7081                   }
7082                   if( !anIsDefinedPlane ) {
7083                     TPlaneInfo aPlaneInfo;
7084                     aPlaneInfo.PlaneId = aPlaneId;
7085                     aPlaneInfo.ActorList.push_back( aSmeshActor );
7086                     aPlaneInfo.ViewManager = vman;
7087
7088                     // to make the list sorted by plane id
7089                     anIter = aPlaneInfoList.begin();
7090                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7091                       const TPlaneInfo& aPlaneInfoRef = *anIter;
7092                       if( aPlaneInfoRef.PlaneId > aPlaneId )
7093                         break;
7094                     }
7095                     aPlaneInfoList.insert( anIter, aPlaneInfo );
7096                   }
7097                 }
7098               }
7099             }
7100           } // if (aSmeshActor)
7101         } // other parameters than Visibility
7102       }
7103     } // for names/parameters iterator
7104   } // for entries iterator
7105
7106   // take into account planes with empty list of actors referred to them
7107   QList<SUIT_ViewManager*> aVMList;
7108   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7109
7110   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7111   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7112     int aViewId = aPlaneDataIter->first;
7113     if( aViewId >= 0 && aViewId < aVMList.count() ) {
7114       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7115
7116       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7117
7118       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7119       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7120       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7121         const TPlaneData& aPlaneData = *anIter2;
7122         int aPlaneId = aPlaneData.Id;
7123
7124         bool anIsFound = false;
7125         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7126         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7127           const TPlaneInfo& aPlaneInfo = *anIter3;
7128           if( aPlaneInfo.PlaneId == aPlaneId ) {
7129             anIsFound = true;
7130             break;
7131           }
7132         }
7133
7134         if( !anIsFound ) {
7135           TPlaneInfo aPlaneInfo; // ActorList field is empty
7136           aPlaneInfo.PlaneId = aPlaneId;
7137           aPlaneInfo.ViewManager = aViewManager;
7138
7139           // to make the list sorted by plane id
7140           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7141           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7142             const TPlaneInfo& aPlaneInfoRef = *anIter4;
7143             if( aPlaneInfoRef.PlaneId > aPlaneId )
7144               break;
7145           }
7146           aPlaneInfoList.insert( anIter4, aPlaneInfo );
7147         }
7148       }
7149     }
7150   }
7151
7152   // add clipping planes to actors according to the restored parameters
7153   // and update the clipping plane map
7154   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7155   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7156     int aViewId = anIter1->first;
7157     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7158
7159     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7160     if( anIter2 == aPlaneDataMap.end() )
7161       continue;
7162     const TPlaneDataList& aPlaneDataList = anIter2->second;
7163
7164     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7165     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7166       const TPlaneInfo& aPlaneInfo = *anIter3;
7167       int aPlaneId = aPlaneInfo.PlaneId;
7168       const TActorList& anActorList = aPlaneInfo.ActorList;
7169       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7170       if( !aViewManager )
7171         continue;
7172
7173       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7174       if( !aViewWindow )
7175         continue;
7176
7177       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7178
7179       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7180       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7181         const TPlaneData& aPlaneData = *anIter4;
7182         if( aPlaneData.Id == aPlaneId ) {
7183           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7184           aPlane->myViewWindow = aViewWindow;
7185           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7186           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7187           if ( aPlane->PlaneMode == SMESH::Absolute ) {
7188             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7189             aPlane->X = aPlaneData.X;
7190             aPlane->Y = aPlaneData.Y;
7191             aPlane->Z = aPlaneData.Z;
7192             aPlane->Dx = aPlaneData.Dx;
7193             aPlane->Dy = aPlaneData.Dy;
7194             aPlane->Dz = aPlaneData.Dz;
7195           }
7196           else if ( aPlane->PlaneMode == SMESH::Relative ) {
7197             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7198             aPlane->myDistance = aPlaneData.Distance;
7199             aPlane->myAngle[0] = aPlaneData.Angle[0];
7200             aPlane->myAngle[1] = aPlaneData.Angle[1];
7201           }
7202           if( aPlane ) {
7203             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7204               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7205               aClippingPlaneInfo.Plane = aPlane;
7206               aClippingPlaneInfo.ActorList = anActorList;
7207               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7208             }
7209           }
7210           break;
7211         }
7212       }
7213
7214     }
7215   }
7216
7217
7218   // update all VTK views
7219   QList<SUIT_ViewManager*> lst;
7220   getApp()->viewManagers(lst);
7221   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7222     SUIT_ViewModel* vmodel = (*it)->getViewModel();
7223     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7224       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7225       // set OpenGL clipping planes
7226       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7227       vtkActorCollection* anAllActors = aCopy.GetActors();
7228       anAllActors->InitTraversal();
7229       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7230         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7231           anActor->SetOpenGLClippingPlane();
7232
7233       vtkView->getRenderer()->ResetCameraClippingRange();
7234       vtkView->Repaint();
7235     }
7236   }
7237 }
7238
7239 /*!
7240   \brief Adds preferences for dfont of VTK viewer
7241   \param label label
7242   \param pIf group identifier
7243   \param param parameter
7244   \return identifier of preferences
7245 */
7246 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7247 {
7248   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7249
7250   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7251
7252   QStringList fam;
7253   fam.append( tr( "SMESH_FONT_ARIAL" ) );
7254   fam.append( tr( "SMESH_FONT_COURIER" ) );
7255   fam.append( tr( "SMESH_FONT_TIMES" ) );
7256
7257   setPreferenceProperty( tfont, "fonts", fam );
7258
7259   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7260   if ( needSize ) f = f | QtxFontEdit::Size;
7261   setPreferenceProperty( tfont, "features", f );
7262
7263   return tfont;
7264 }
7265
7266 /*!
7267   \brief Actions after hypothesis edition
7268   Updates object browser after hypothesis edition
7269 */
7270 void SMESHGUI::onHypothesisEdit( int result )
7271 {
7272   if( result == 1 )
7273     SMESHGUI::Modified();
7274   updateObjBrowser( true );
7275 }
7276
7277 /*!
7278   \brief Actions after choosing menu of control modes
7279   Updates control mode actions according to current selection
7280 */
7281 void SMESHGUI::onUpdateControlActions()
7282 {
7283   SALOME_ListIO selected;
7284   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7285     aSel->selectedObjects( selected );
7286
7287   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7288   if ( selected.Extent() ) {
7289     if ( selected.First()->hasEntry() ) {
7290       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7291         aControl = anActor->GetControlMode();
7292         SALOME_ListIteratorOfListIO it(selected);
7293         for ( it.Next(); it.More(); it.Next() ) {
7294           Handle(SALOME_InteractiveObject) anIO = it.Value();
7295           if ( anIO->hasEntry() ) {
7296             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7297               if ( aControl != anActor->GetControlMode() ) {
7298                 aControl = SMESH_Actor::eNone;
7299                 break;
7300               }
7301             }
7302           }
7303         }
7304       }
7305     }
7306   }
7307
7308   int anAction = ActionToControl( aControl, true );
7309   if ( anAction)
7310     action( anAction )->setChecked( true );
7311   else {
7312     QMenu* send = (QMenu*)sender();
7313     QList<QAction*> actions = send->actions();
7314     for ( int i = 0; i < actions.size(); i++ )
7315       actions[i]->setChecked( false );
7316   }
7317 }
7318
7319
7320 /*!
7321   \brief Signal handler closing(SUIT_ViewWindow*) of a view
7322   \param pview view being closed
7323 */
7324 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7325 #ifndef DISABLE_PLOT2DVIEWER
7326   //Crear all Plot2d Viewers if need.
7327   SMESH::ClearPlot2Viewers(pview);
7328 #endif
7329   EmitSignalCloseView();
7330 }
7331
7332 void SMESHGUI::message( const QString& msg )
7333 {
7334   // dispatch message
7335   QStringList data = msg.split("/");
7336   if ( data.count() > 0 ) {
7337     if ( data.first() == "mesh_loading" ) {
7338       // get mesh entry
7339       QString entry = data.count() > 1 ? data[1] : QString();
7340       if ( entry.isEmpty() )
7341         return;
7342       // get study
7343       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7344       // get mesh name
7345       _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7346       QString name;
7347       if ( obj )
7348         name = SMESH::fromUtf8(obj->GetName());
7349       if ( name.isEmpty() )
7350         return;
7351
7352       if ( data.last() == "stop" )
7353         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7354       else
7355         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7356       QApplication::processEvents();
7357     }
7358   }
7359 }
7360
7361 /*!
7362   \brief Connects or disconnects signals about activating and cloning view on the module slots
7363   \param pview view which is connected/disconnected
7364 */
7365 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7366   if(!pview)
7367     return;
7368
7369   SUIT_ViewManager* viewMgr = pview->getViewManager();
7370   if ( viewMgr ) {
7371     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7372                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7373
7374     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7375              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7376   }
7377 }
7378
7379 /*!
7380   \brief Return \c true if object can be renamed
7381 */
7382 bool SMESHGUI::renameAllowed( const QString& entry) const {
7383   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7384   if( !anApp )
7385     return false;
7386
7387   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7388   if( !appStudy )
7389     return false;
7390
7391   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7392
7393   if(!obj)
7394     return false;
7395
7396   if(appStudy->isComponent(entry) || obj->isReference())
7397     return false;
7398
7399   // check type to prevent renaming of inappropriate objects
7400   int aType = SMESHGUI_Selection::type(qPrintable(entry));
7401   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7402       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7403       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7404       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7405       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7406     return true;
7407
7408   return false;
7409 }
7410
7411 /*!
7412   Rename object by entry.
7413   \param entry entry of the object
7414   \param name new name of the object
7415   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7416 */
7417 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7418
7419   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7420   if( !anApp )
7421     return false;
7422
7423   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7424
7425   if(!appStudy)
7426     return false;
7427
7428   _PTR(Study) aStudy = appStudy->studyDS();
7429
7430   if(!aStudy)
7431     return false;
7432
7433   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7434   if ( aLocked ) {
7435     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7436     return false;
7437   }
7438
7439
7440   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7441   _PTR(GenericAttribute) anAttr;
7442   _PTR(AttributeName) aName;
7443   if ( obj ) {
7444     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7445       aName = anAttr;
7446       // check type to prevent renaming of inappropriate objects
7447       int aType = SMESHGUI_Selection::type( qPrintable(entry));
7448       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7449           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7450           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7451           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7452           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7453         if ( !name.isEmpty() ) {
7454           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7455
7456           // update name of group object and its actor
7457           Handle(SALOME_InteractiveObject) IObject =
7458             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7459
7460           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7461           if( !aGroupObject->_is_nil() ) {
7462             aGroupObject->SetName( qUtf8Printable(name) );
7463             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7464               anActor->setName( qUtf8Printable(name) );
7465           }
7466           return true;
7467         }
7468       }
7469     }
7470   }
7471   return false;
7472 }
7473
7474 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7475 {
7476   static QList<QColor> colors;
7477
7478   if ( colors.isEmpty() ) {
7479
7480     for (int s = 0; s < 2 ; s++)
7481     {
7482       for (int v = 100; v >= 40; v = v - 20)
7483       {
7484         for (int h = 0; h < 359 ; h = h + 60)
7485         {
7486           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7487         }
7488       }
7489     }
7490   }
7491   static int currentColor = randomize( colors.size() );
7492
7493   SALOMEDS::Color color;
7494   color.R = (double)colors[currentColor].red()   / 255.0;
7495   color.G = (double)colors[currentColor].green() / 255.0;
7496   color.B = (double)colors[currentColor].blue()  / 255.0;
7497
7498   currentColor = (currentColor+1) % colors.count();
7499
7500   return color;
7501 }