src/SMESHGUI/SMESHGUI.cxx

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