src/SMESHGUI/SMESHGUI.cxx

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