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