src/SMESHGUI/SMESHGUI.cxx

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