src/SMESHGUI/SMESHGUI.cxx

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