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::OpMGAdapt:
3040     {
3041       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3042       SMESHGUI_AdaptDlg *objet = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
3043     }
3044   // Adaptation - end
3045   case SMESHOp::OpSplitBiQuadratic:
3046   case SMESHOp::OpConvertMeshToQuadratic:
3047   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3048   case SMESHOp::OpReorientFaces:
3049   case SMESHOp::OpCreateGeometryGroup:
3050     {
3051       if ( warnOnGeomModif() )
3052         break; // action forbidden as geometry modified
3053       startOperation( theCommandID );
3054       break;
3055     }
3056   case SMESHOp::OpCreateGroup:
3057     {
3058       if ( !vtkwnd )
3059       {
3060         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3061         break;
3062       }
3063
3064       if(isStudyLocked()) break;
3065       if ( warnOnGeomModif() )
3066         break; // action forbidden as geometry modified
3067       EmitSignalDeactivateDialog();
3068       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3069
3070       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3071       SALOME_ListIO selected;
3072       if( aSel )
3073         aSel->selectedObjects( selected );
3074
3075       int nbSel = selected.Extent();
3076       if (nbSel == 1) {
3077         // check if mesh is selected
3078         aMesh = SMESH::GetMeshByIO( selected.First() );
3079       }
3080       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3081       aDlg->show();
3082       break;
3083     }
3084
3085   case SMESHOp::OpConstructGroup:
3086     {
3087       if ( !vtkwnd )
3088       {
3089         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3090         break;
3091       }
3092
3093       if(isStudyLocked()) break;
3094       if ( warnOnGeomModif() )
3095         break; // action forbidden as geometry modified
3096       EmitSignalDeactivateDialog();
3097
3098       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3099       SALOME_ListIO selected;
3100       if( aSel )
3101         aSel->selectedObjects( selected );
3102
3103       int nbSel = selected.Extent();
3104       if (nbSel == 1) {
3105         // check if submesh is selected
3106         Handle(SALOME_InteractiveObject) IObject = selected.First();
3107         if (IObject->hasEntry()) {
3108           _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3109           if( aSObj ) {
3110             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3111             if (!aSubMesh->_is_nil()) {
3112               try {
3113                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3114                 // get submesh elements list by types
3115                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3116                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3117                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3118                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3119                 // create group for each type o elements
3120                 QString aName = IObject->getName();
3121                 QStringList anEntryList;
3122                 if (aNodes->length() > 0) {
3123                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3124                   aGroup->Add(aNodes.inout());
3125                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3126                     anEntryList.append( aSObject->GetID().c_str() );
3127                 }
3128                 if (aEdges->length() > 0) {
3129                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3130                   aGroup->Add(aEdges.inout());
3131                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3132                     anEntryList.append( aSObject->GetID().c_str() );
3133                 }
3134                 if (aFaces->length() > 0) {
3135                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3136                   aGroup->Add(aFaces.inout());
3137                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3138                     anEntryList.append( aSObject->GetID().c_str() );
3139                 }
3140                 if (aVolumes->length() > 0) {
3141                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3142                   aGroup->Add(aVolumes.inout());
3143                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3144                     anEntryList.append( aSObject->GetID().c_str() );
3145                 }
3146                 updateObjBrowser();
3147                 anApp->browseObjects( anEntryList );
3148               }
3149               catch(const SALOME::SALOME_Exception & S_ex){
3150                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3151               }
3152             }
3153           }
3154         }
3155       }
3156       else if(nbSel==0) {
3157         SUIT_MessageBox::warning(desktop(),
3158                                  tr("SMESH_WRN_WARNING"),
3159                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3160       }
3161       break;
3162     }
3163
3164   case SMESHOp::OpEditGroup:
3165     {
3166       if ( !vtkwnd )
3167       {
3168         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3169         break;
3170       }
3171
3172       if(isStudyLocked()) break;
3173       if ( warnOnGeomModif() )
3174         break; // action forbidden as geometry modified
3175       EmitSignalDeactivateDialog();
3176
3177       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3178       SALOME_ListIO selected;
3179       if( aSel )
3180         aSel->selectedObjects( selected );
3181
3182       SALOME_ListIteratorOfListIO It (selected);
3183       int nbSelectedGroups = 0;
3184       for ( ; It.More(); It.Next() )
3185       {
3186         SMESH::SMESH_GroupBase_var aGroup =
3187           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3188         if (!aGroup->_is_nil()) {
3189           nbSelectedGroups++;
3190           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3191           aDlg->show();
3192         }
3193       }
3194       if (nbSelectedGroups == 0)
3195         {
3196           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3197           aDlg->show();
3198         }
3199       break;
3200     }
3201
3202   case SMESHOp::OpAddElemGroupPopup:     // Add elements to group
3203     {
3204       if(isStudyLocked()) break;
3205       if (myState == 800) {
3206         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3207         if (aDlg) aDlg->onAdd();
3208       }
3209       break;
3210     }
3211
3212   case SMESHOp::OpRemoveElemGroupPopup:  // Remove elements from group
3213     {
3214       if(isStudyLocked()) break;
3215       if (myState == 800) {
3216         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3217         if (aDlg) aDlg->onRemove();
3218       }
3219       break;
3220     }
3221
3222   case SMESHOp::OpEditGeomGroupAsGroup:
3223     {
3224       if ( !vtkwnd )
3225       {
3226         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3227         break;
3228       }
3229
3230       if(isStudyLocked()) break;
3231       EmitSignalDeactivateDialog();
3232
3233       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3234       SALOME_ListIO selected;
3235       if( aSel )
3236         aSel->selectedObjects( selected );
3237
3238       SALOME_ListIteratorOfListIO It (selected);
3239       for ( ; It.More(); It.Next() )
3240       {
3241         SMESH::SMESH_GroupOnGeom_var aGroup =
3242           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3243         if (!aGroup->_is_nil()) {
3244           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3245           aDlg->show();
3246         }
3247         else
3248         {
3249           SMESH::SMESH_GroupOnFilter_var aGroup =
3250             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3251           if (!aGroup->_is_nil()) {
3252             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3253             aDlg->show();
3254           }
3255         }
3256       }
3257       break;
3258     }
3259
3260     case SMESHOp::OpUnionGroups:
3261     case SMESHOp::OpIntersectGroups:
3262     case SMESHOp::OpCutGroups:
3263     {
3264       if ( !vtkwnd )
3265       {
3266         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3267         break;
3268       }
3269
3270       if ( isStudyLocked() )
3271         break;
3272       if ( warnOnGeomModif() )
3273         break; // action forbidden as geometry modified
3274
3275       EmitSignalDeactivateDialog();
3276
3277       SMESHGUI_GroupOpDlg* aDlg = 0;
3278       if ( theCommandID == SMESHOp::OpUnionGroups )
3279         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3280       else if ( theCommandID == SMESHOp::OpIntersectGroups )
3281         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3282       else
3283         aDlg = new SMESHGUI_CutGroupsDlg( this );
3284
3285       aDlg->show();
3286
3287       break;
3288     }
3289
3290     case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3291     {
3292       if ( isStudyLocked() )
3293         break;
3294       if ( warnOnGeomModif() )
3295         break; // action forbidden as geometry modified
3296
3297       EmitSignalDeactivateDialog();
3298       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3299       aDlg->show();
3300
3301       break;
3302     }
3303
3304     case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3305     {
3306       if ( isStudyLocked() )
3307         break;
3308       if ( warnOnGeomModif() )
3309         break; // action forbidden as geometry modified
3310
3311       EmitSignalDeactivateDialog();
3312       SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3313       aDlg->show();
3314
3315       break;
3316     }
3317
3318     case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3319     {
3320       if ( !vtkwnd )
3321       {
3322         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3323         break;
3324       }
3325
3326       if ( isStudyLocked() )
3327         break;
3328
3329       EmitSignalDeactivateDialog();
3330
3331       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3332       break;
3333     }
3334
3335   case SMESHOp::OpMeshInformation:
3336   case SMESHOp::OpWhatIs:
3337     {
3338       int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3339       EmitSignalDeactivateDialog();
3340       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3341       SALOME_ListIO selected;
3342       if( aSel )
3343         aSel->selectedObjects( selected );
3344
3345       if ( selected.Extent() > 1 ) { // a dlg for each IO
3346         SALOME_ListIteratorOfListIO It( selected );
3347         for ( ; It.More(); It.Next() ) {
3348           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3349           dlg->showInfo( It.Value() );
3350           dlg->show();
3351         }
3352       }
3353       else {
3354         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3355         dlg->show();
3356       }
3357       break;
3358     }
3359
3360   case SMESHOp::OpFindElementByPoint:
3361     {
3362       startOperation( theCommandID );
3363       break;
3364     }
3365
3366   case SMESHOp::OpEditHypothesis:
3367     {
3368       if(isStudyLocked()) break;
3369       if ( warnOnGeomModif() )
3370         break; // action forbidden as geometry modified
3371
3372       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3373       SALOME_ListIO selected;
3374       if( aSel )
3375         aSel->selectedObjects( selected );
3376
3377       int nbSel = selected.Extent();
3378
3379       if (nbSel == 1) {
3380         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3381         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3382
3383         if ( !aHypothesis->_is_nil() )
3384         {
3385           SMESHGUI_GenericHypothesisCreator* aCreator =
3386             SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3387           if (aCreator)
3388           {
3389             // set geometry of mesh and sub-mesh to aCreator
3390             aSel->selectedObjects( selected, "",  /*convertReferences=*/false);
3391             if ( selected.Extent() == 1 )
3392             {
3393               QString subGeomID, meshGeomID;
3394               Handle(SALOME_InteractiveObject) hypIO = selected.First();
3395               if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3396               {
3397                 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3398                 aCreator->setShapeEntry( subGeomID );
3399                 aCreator->setMainShapeEntry( meshGeomID );
3400               }
3401             }
3402
3403             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3404           }
3405           else
3406           {
3407             // report error
3408           }
3409         }
3410       }
3411       break;
3412     }
3413   case SMESHOp::OpUnassign:                      // REMOVE HYPOTHESIS / ALGORITHMS
3414     {
3415       if(isStudyLocked()) break;
3416       if ( warnOnGeomModif() )
3417         break; // action forbidden as geometry modified
3418       SUIT_OverrideCursor wc;
3419
3420       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3421       SALOME_ListIO selected;
3422       if( aSel )
3423         aSel->selectedObjects( selected, QString::null, false );
3424
3425       SALOME_ListIteratorOfListIO It(selected);
3426       for (int i = 0; It.More(); It.Next(), i++) {
3427         Handle(SALOME_InteractiveObject) IObject = It.Value();
3428         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3429       }
3430       SALOME_ListIO l1;
3431       aSel->setSelectedObjects( l1 );
3432       updateObjBrowser();
3433       break;
3434     }
3435
3436   case SMESHOp::OpElem0D:
3437   case SMESHOp::OpBall:
3438   case SMESHOp::OpEdge:
3439   case SMESHOp::OpTriangle:
3440   case SMESHOp::OpQuadrangle:
3441   case SMESHOp::OpPolygon:
3442   case SMESHOp::OpTetrahedron:
3443   case SMESHOp::OpHexahedron:
3444   case SMESHOp::OpPentahedron:
3445   case SMESHOp::OpPyramid:
3446   case SMESHOp::OpHexagonalPrism:
3447     {
3448       if(isStudyLocked()) break;
3449       if ( warnOnGeomModif() )
3450         break; // action forbidden as geometry modified
3451       if ( vtkwnd ) {
3452         EmitSignalDeactivateDialog();
3453         SMDSAbs_EntityType type = SMDSEntity_Edge;
3454         switch (theCommandID) {
3455         case SMESHOp::OpElem0D: type = SMDSEntity_0D;                      break;
3456         case SMESHOp::OpBall: type = SMDSEntity_Ball;                      break;
3457         case SMESHOp::OpTriangle: type = SMDSEntity_Triangle;              break;
3458         case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle;          break;
3459         case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra;              break;
3460         case SMESHOp::OpPolygon: type = SMDSEntity_Polygon;                break;
3461         case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa;                break;
3462         case SMESHOp::OpPentahedron: type = SMDSEntity_Penta;              break;
3463         case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid;                break;
3464         case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3465         default:;
3466         }
3467         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3468       }
3469       else {
3470         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3471       }
3472       break;
3473     }
3474   case SMESHOp::OpPolyhedron:
3475     {
3476       if(isStudyLocked()) break;
3477       if ( warnOnGeomModif() )
3478         break; // action forbidden as geometry modified
3479       if ( vtkwnd ) {
3480         EmitSignalDeactivateDialog();
3481         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3482       }
3483       else {
3484         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3485       }
3486       break;
3487     }
3488   case SMESHOp::OpQuadraticEdge:
3489   case SMESHOp::OpQuadraticTriangle:
3490   case SMESHOp::OpBiQuadraticTriangle:
3491   case SMESHOp::OpQuadraticQuadrangle:
3492   case SMESHOp::OpBiQuadraticQuadrangle:
3493   case SMESHOp::OpQuadraticPolygon:
3494   case SMESHOp::OpQuadraticTetrahedron:
3495   case SMESHOp::OpQuadraticPyramid:
3496   case SMESHOp::OpQuadraticPentahedron:
3497   case SMESHOp::OpBiQuadraticPentahedron:
3498   case SMESHOp::OpQuadraticHexahedron:
3499   case SMESHOp::OpTriQuadraticHexahedron:
3500     {
3501       if(isStudyLocked()) break;
3502       if ( warnOnGeomModif() )
3503         break; // action forbidden as geometry modified
3504       if ( vtkwnd ) {
3505         EmitSignalDeactivateDialog();
3506         SMDSAbs_EntityType type = SMDSEntity_Last;
3507
3508         switch (theCommandID) {
3509         case SMESHOp::OpQuadraticEdge:          type = SMDSEntity_Quad_Edge; break;
3510         case SMESHOp::OpQuadraticTriangle:      type = SMDSEntity_Quad_Triangle; break;
3511         case SMESHOp::OpBiQuadraticTriangle:    type = SMDSEntity_BiQuad_Triangle; break;
3512         case SMESHOp::OpQuadraticQuadrangle:    type = SMDSEntity_Quad_Quadrangle; break;
3513         case SMESHOp::OpBiQuadraticQuadrangle:  type = SMDSEntity_BiQuad_Quadrangle; break;
3514         case SMESHOp::OpQuadraticPolygon:       type = SMDSEntity_Quad_Polygon; break;
3515         case SMESHOp::OpQuadraticTetrahedron:   type = SMDSEntity_Quad_Tetra; break;
3516         case SMESHOp::OpQuadraticPyramid:       type = SMDSEntity_Quad_Pyramid; break;
3517         case SMESHOp::OpQuadraticPentahedron:   type = SMDSEntity_Quad_Penta; break;
3518         case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3519         case SMESHOp::OpQuadraticHexahedron:    type = SMDSEntity_Quad_Hexa; break;
3520         case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3521         default: break;
3522         }
3523         if ( type != SMDSEntity_Last )
3524           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3525       }
3526       else {
3527         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3528                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3529       }
3530       break;
3531     }
3532   case SMESHOp::OpRemoveNodes:
3533     {
3534       if(isStudyLocked()) break;
3535       if ( warnOnGeomModif() )
3536         break; // action forbidden as geometry modified
3537       if ( vtkwnd ) {
3538         EmitSignalDeactivateDialog();
3539         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3540       }
3541       else {
3542         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3543                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3544       }
3545       break;
3546     }
3547   case SMESHOp::OpRemoveElements:                                    // REMOVES ELEMENTS
3548     {
3549       if(isStudyLocked()) break;
3550       if ( warnOnGeomModif() )
3551         break; // action forbidden as geometry modified
3552       if( vtkwnd ) {
3553         EmitSignalDeactivateDialog();
3554         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3555       }
3556       else
3557         {
3558           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3559                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3560         }
3561       break;
3562     }
3563   case SMESHOp::OpClearMesh: {
3564
3565     if(isStudyLocked()) break;
3566     if ( warnOnGeomModif() )
3567       break; // action forbidden as geometry modified
3568
3569     SALOME_ListIO selected;
3570     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3571       aSel->selectedObjects( selected );
3572
3573     SUIT_OverrideCursor wc;
3574     SALOME_ListIteratorOfListIO It (selected);
3575     for ( ; It.More(); It.Next() )
3576     {
3577       Handle(SALOME_InteractiveObject) IOS = It.Value();
3578       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3579       if ( aMesh->_is_nil()) continue;
3580       try {
3581         aMesh->Clear();
3582         if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3583           SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3584         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3585         // hide groups and submeshes
3586         _PTR(ChildIterator) anIter =
3587           SMESH::getStudy()->NewChildIterator( aMeshSObj );
3588         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3589         {
3590           _PTR(SObject) so = anIter->Value();
3591           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3592         }
3593       }
3594       catch (const SALOME::SALOME_Exception& S_ex){
3595         wc.suspend();
3596         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3597         wc.resume();
3598       }
3599     }
3600     SMESH::UpdateView();
3601     updateObjBrowser();
3602     break;
3603   }
3604   case SMESHOp::OpRemoveOrphanNodes:
3605     {
3606       if(isStudyLocked()) break;
3607       if ( warnOnGeomModif() )
3608         break; // action forbidden as geometry modified
3609       SALOME_ListIO selected;
3610       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3611         aSel->selectedObjects( selected );
3612       if ( selected.Extent() == 1 ) {
3613         Handle(SALOME_InteractiveObject) anIO = selected.First();
3614         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3615         if ( !aMesh->_is_nil() ) {
3616           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3617                                                     tr( "SMESH_WARNING" ),
3618                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3619                                                     SUIT_MessageBox::Yes |
3620                                                     SUIT_MessageBox::No,
3621                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3622           if( confirm ) {
3623             try {
3624               SUIT_OverrideCursor wc;
3625               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3626               int removed = aMeshEditor->RemoveOrphanNodes();
3627               SUIT_MessageBox::information(SMESHGUI::desktop(),
3628                                            tr("SMESH_INFORMATION"),
3629                                            tr("NB_NODES_REMOVED").arg(removed));
3630               if ( removed > 0 ) {
3631                 SMESH::UpdateView();
3632                 SMESHGUI::Modified();
3633               }
3634             }
3635             catch (const SALOME::SALOME_Exception& S_ex) {
3636               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3637             }
3638             catch (...) {
3639             }
3640           }
3641         }
3642       }
3643       break;
3644     }
3645   case SMESHOp::OpRenumberingNodes:
3646     {
3647       if(isStudyLocked()) break;
3648       if ( warnOnGeomModif() )
3649         break; // action forbidden as geometry modified
3650       if( vtkwnd ) {
3651         EmitSignalDeactivateDialog();
3652         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3653       }
3654       else
3655         {
3656           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3657                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3658         }
3659       break;
3660     }
3661   case SMESHOp::OpRenumberingElements:
3662     {
3663       if(isStudyLocked()) break;
3664       if ( warnOnGeomModif() )
3665         break; // action forbidden as geometry modified
3666       if ( vtkwnd ) {
3667         EmitSignalDeactivateDialog();
3668         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3669       }
3670       else
3671         {
3672           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3673                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3674         }
3675       break;
3676     }
3677   case SMESHOp::OpTranslation:
3678     {
3679       if(isStudyLocked()) break;
3680       if ( warnOnGeomModif() )
3681         break; // action forbidden as geometry modified
3682       if ( vtkwnd ) {
3683         EmitSignalDeactivateDialog();
3684         ( new SMESHGUI_TranslationDlg( this ) )->show();
3685       }
3686       else {
3687         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3688                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3689       }
3690       break;
3691     }
3692   case SMESHOp::OpRotation:
3693     {
3694       if(isStudyLocked()) break;
3695       if ( warnOnGeomModif() )
3696         break; // action forbidden as geometry modified
3697       if( vtkwnd ) {
3698         EmitSignalDeactivateDialog();
3699         ( new SMESHGUI_RotationDlg( this ) )->show();
3700       }
3701       else {
3702         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3703                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3704       }
3705       break;
3706     }
3707   case SMESHOp::OpSymmetry:
3708     {
3709       if(isStudyLocked()) break;
3710       if ( warnOnGeomModif() )
3711         break; // action forbidden as geometry modified
3712       if(vtkwnd) {
3713         EmitSignalDeactivateDialog();
3714         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3715       }
3716       else {
3717         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3718                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3719       }
3720       break;
3721     }
3722   case SMESHOp::OpScale:
3723     {
3724       if(isStudyLocked()) break;
3725       if ( warnOnGeomModif() )
3726         break; // action forbidden as geometry modified
3727       if ( vtkwnd ) {
3728         EmitSignalDeactivateDialog();
3729         ( new SMESHGUI_ScaleDlg( this ) )->show();
3730       }
3731       else {
3732         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3733                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3734       }
3735       break;
3736     }
3737
3738   case SMESHOp::OpOffset:
3739     {
3740       if(isStudyLocked()) break;
3741       if ( warnOnGeomModif() )
3742         break; // action forbidden as geometry modified
3743       if ( vtkwnd ) {
3744         EmitSignalDeactivateDialog();
3745         ( new SMESHGUI_OffsetDlg( this ) )->show();
3746       }
3747       else {
3748         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3749                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3750       }
3751       break;
3752     }
3753
3754   case SMESHOp::OpSewing:
3755     {
3756       if(isStudyLocked()) break;
3757       if ( warnOnGeomModif() )
3758         break; // action forbidden as geometry modified
3759       if(vtkwnd) {
3760         EmitSignalDeactivateDialog();
3761         ( new SMESHGUI_SewingDlg( this ) )->show();
3762       }
3763       else {
3764         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3765                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3766       }
3767       break;
3768     }
3769   case SMESHOp::OpMergeNodes:
3770     {
3771       if(isStudyLocked()) break;
3772       if ( warnOnGeomModif() )
3773         break; // action forbidden as geometry modified
3774       if(vtkwnd) {
3775         EmitSignalDeactivateDialog();
3776         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3777       }
3778       else {
3779         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3780                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3781       }
3782       break;
3783     }
3784   case SMESHOp::OpMergeElements:
3785     {
3786       if (isStudyLocked()) break;
3787       if ( warnOnGeomModif() )
3788         break; // action forbidden as geometry modified
3789       if (vtkwnd) {
3790         EmitSignalDeactivateDialog();
3791         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3792       } else {
3793         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3794                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3795       }
3796       break;
3797     }
3798
3799   case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3800     if ( warnOnGeomModif() )
3801       break; // action forbidden as geometry modified
3802     startOperation( SMESHOp::OpMoveNode );
3803     break;
3804
3805   case SMESHOp::OpDuplicateNodes:
3806     {
3807       if(isStudyLocked()) break;
3808       if ( warnOnGeomModif() )
3809         break; // action forbidden as geometry modified
3810       if ( vtkwnd ) {
3811         EmitSignalDeactivateDialog();
3812         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3813       }
3814       else {
3815         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3816                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3817       }
3818       break;
3819     }
3820
3821   case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3822     if ( warnOnGeomModif() )
3823       break; // action forbidden as geometry modified
3824     startOperation( SMESHOp::OpElem0DOnElemNodes );
3825     break;
3826
3827   case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3828   {
3829     static QList<int> aTypes;
3830     if ( aTypes.isEmpty() )
3831     {
3832       aTypes.append( SMESH::NODE );
3833       aTypes.append( SMESH::EDGE );
3834       aTypes.append( SMESH::FACE );
3835       aTypes.append( SMESH::VOLUME );
3836     }
3837     if (!myFilterLibraryDlg)
3838       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3839     else if (myFilterLibraryDlg->isHidden())
3840       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3841     myFilterLibraryDlg->raise();
3842   }
3843   break;
3844   // CONTROLS
3845   case SMESHOp::OpFreeNode:
3846   case SMESHOp::OpEqualNode:
3847   case SMESHOp::OpNodeConnectivityNb:
3848   case SMESHOp::OpFreeEdge:
3849   case SMESHOp::OpFreeBorder:
3850   case SMESHOp::OpLength:
3851   case SMESHOp::OpConnection:
3852   case SMESHOp::OpEqualEdge:
3853   case SMESHOp::OpFreeFace:
3854   case SMESHOp::OpBareBorderFace:
3855   case SMESHOp::OpOverConstrainedFace:
3856   case SMESHOp::OpLength2D:
3857   case SMESHOp::OpDeflection2D:
3858   case SMESHOp::OpConnection2D:
3859   case SMESHOp::OpArea:
3860   case SMESHOp::OpTaper:
3861   case SMESHOp::OpAspectRatio:
3862   case SMESHOp::OpMinimumAngle:
3863   case SMESHOp::OpWarpingAngle:
3864   case SMESHOp::OpSkew:
3865   case SMESHOp::OpMaxElementLength2D:
3866   case SMESHOp::OpEqualFace:
3867   case SMESHOp::OpAspectRatio3D:
3868   case SMESHOp::OpVolume:
3869   case SMESHOp::OpMaxElementLength3D:
3870   case SMESHOp::OpBareBorderVolume:
3871   case SMESHOp::OpOverConstrainedVolume:
3872   case SMESHOp::OpEqualVolume:
3873     if ( vtkwnd ) {
3874
3875       LightApp_SelectionMgr* mgr = selectionMgr();
3876       SALOME_ListIO selected; mgr->selectedObjects( selected );
3877
3878       if( !selected.IsEmpty() ) {
3879         SUIT_OverrideCursor wc;
3880         ::Control( theCommandID );
3881         break;
3882       }
3883       SUIT_MessageBox::warning(desktop(),
3884                                tr( "SMESH_WRN_WARNING" ),
3885                                tr( "SMESH_BAD_SELECTION" ) );
3886       break;
3887     }
3888     else {
3889       SUIT_MessageBox::warning(desktop(),
3890                                tr( "SMESH_WRN_WARNING" ),
3891                                tr( "NOT_A_VTK_VIEWER" ) );
3892     }
3893     break;
3894   case SMESHOp::OpOverallMeshQuality:
3895     OverallMeshQuality();
3896     break;
3897   case SMESHOp::OpNumberingNodes:
3898     {
3899       SUIT_OverrideCursor wc;
3900       LightApp_SelectionMgr* mgr = selectionMgr();
3901       SALOME_ListIO selected; mgr->selectedObjects( selected );
3902
3903       SALOME_ListIteratorOfListIO it(selected);
3904       for( ; it.More(); it.Next()) {
3905         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3906         if(anIObject->hasEntry()) {
3907           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3908             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3909           }
3910         }
3911       }
3912       break;
3913     }
3914   case SMESHOp::OpNumberingElements:
3915     {
3916       SUIT_OverrideCursor wc;
3917       LightApp_SelectionMgr* mgr = selectionMgr();
3918       SALOME_ListIO selected; mgr->selectedObjects( selected );
3919
3920       SALOME_ListIteratorOfListIO it(selected);
3921       for( ; it.More(); it.Next()) {
3922         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3923         if(anIObject->hasEntry())
3924           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3925             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3926           }
3927       }
3928       break;
3929     }
3930   case SMESHOp::OpPropertiesLength:
3931   case SMESHOp::OpPropertiesArea:
3932   case SMESHOp::OpPropertiesVolume:
3933   case SMESHOp::OpMinimumDistance:
3934   case SMESHOp::OpBoundingBox:
3935   case SMESHOp::OpAngle:
3936     {
3937       int page = SMESHGUI_MeasureDlg::MinDistance;
3938       if ( theCommandID == SMESHOp::OpBoundingBox )
3939         page = SMESHGUI_MeasureDlg::BoundingBox;
3940       else if ( theCommandID == SMESHOp::OpPropertiesLength )
3941         page = SMESHGUI_MeasureDlg::Length;
3942       else if ( theCommandID == SMESHOp::OpPropertiesArea )
3943         page = SMESHGUI_MeasureDlg::Area;
3944       else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3945         page = SMESHGUI_MeasureDlg::Volume;
3946       else if ( theCommandID == SMESHOp::OpAngle )
3947         page = SMESHGUI_MeasureDlg::Angle;
3948
3949       EmitSignalDeactivateDialog();
3950       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3951       dlg->show();
3952       break;
3953     }
3954   case SMESHOp::OpSortChild:
3955     ::sortChildren();
3956     break;
3957   case SMESHOp::OpBreakLink:
3958     ::breakShaperLink();
3959     break;
3960
3961   }
3962
3963   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3964   //updateObjBrowser();
3965   return true;
3966 }
3967
3968 //=============================================================================
3969 /*!
3970  *
3971  */
3972 //=============================================================================
3973 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3974 {
3975   return false;
3976 }
3977
3978 //=============================================================================
3979 /*!
3980  *
3981  */
3982 //=============================================================================
3983 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3984 {
3985   return true;
3986 }
3987
3988 //=============================================================================
3989 /*!
3990  *
3991  */
3992 //=============================================================================
3993 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3994 {
3995   return true;
3996 }
3997
3998 //=============================================================================
3999 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4000  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4001  */
4002 //=============================================================================
4003 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4004                                   SUIT_ViewWindow* wnd )
4005 {
4006   if(theIO->hasEntry()){
4007     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4008     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4009   }
4010 }
4011
4012 //=======================================================================
4013 // function : createSMESHAction
4014 // purpose  :
4015 //=======================================================================
4016 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4017                                   const int key, const bool toggle, const QString& shortcutAction  )
4018 {
4019   QIcon icon;
4020   QWidget* parent = application()->desktop();
4021   SUIT_ResourceMgr* resMgr = resourceMgr();
4022   QPixmap pix;
4023   if ( !icon_id.isEmpty() )
4024     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4025   else
4026     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4027   if ( !pix.isNull() )
4028     icon = QIcon( pix );
4029
4030   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4031           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4032           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4033
4034   createAction( id, tooltip, icon, menu, status_bar, key, parent,
4035                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4036 }
4037
4038 //=======================================================================
4039 // function : createPopupItem
4040 // purpose  :
4041 //=======================================================================
4042 void SMESHGUI::createPopupItem( const int id,
4043                                 const QString& clients,
4044                                 const QString& types,
4045                                 const QString& theRule,
4046                                 const int pId )
4047 {
4048   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4049     popupMgr()->insert( action( id ), pId, 0 );
4050
4051   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4052   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4053   QString rule = "(%1) and (%2) and (%3)";
4054   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4055   if( clients.isEmpty() )
4056     rule = rule.arg( QString( "true" ) );
4057   else
4058     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4059   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4060   rule += theRule;
4061
4062   bool cont = myRules.contains( id );
4063   if( cont )
4064     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4065
4066   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4067   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4068 }
4069
4070 //=======================================================================
4071 // function : initialize
4072 // purpose  :
4073 //=======================================================================
4074 void SMESHGUI::initialize( CAM_Application* app )
4075 {
4076   SalomeApp_Module::initialize( app );
4077
4078 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
4079 //   if ( mgr )
4080   /* Automatic Update flag */
4081 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4082
4083   // ----- create actions --------------
4084
4085   //createSMESHAction(  SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4086   createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4087   createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4088   createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL"  );
4089 #ifdef WITH_CGNS
4090   createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4091 #endif
4092   createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4093   createSMESHAction( SMESHOp::OpImportGMF,  "IMPORT_GMF"  );
4094   createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4095   createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4096   createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL"  );
4097 #ifdef WITH_CGNS
4098   createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4099 #endif
4100   createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4101   createSMESHAction( SMESHOp::OpPopupImportGMF,  "IMPORT_GMF"  );
4102
4103   createSMESHAction( SMESHOp::OpExportDAT,  "DAT" );
4104   createSMESHAction( SMESHOp::OpExportMED,  "MED" );
4105   createSMESHAction( SMESHOp::OpExportUNV,  "UNV" );
4106   createSMESHAction( SMESHOp::OpExportSTL,  "STL" );
4107 #ifdef WITH_CGNS
4108   createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4109 #endif
4110   createSMESHAction( SMESHOp::OpExportSAUV,     "SAUV");
4111   createSMESHAction( SMESHOp::OpExportGMF,      "GMF" );
4112   createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4113   createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4114   createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4115   createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4116 #ifdef WITH_CGNS
4117   createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4118 #endif
4119   createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4120   createSMESHAction( SMESHOp::OpPopupExportGMF,  "GMF" );
4121   createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4122   createSMESHAction( SMESHOp::OpDelete,          "DELETE", "ICON_DELETE", Qt::Key_Delete );
4123   createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4124   createSMESHAction( SMESHOp::OpCreateMesh,           "CREATE_MESH",             "ICON_DLG_INIT_MESH" );
4125   createSMESHAction( SMESHOp::OpCreateSubMesh,        "CREATE_SUBMESH",          "ICON_DLG_ADD_SUBMESH" );
4126   createSMESHAction( SMESHOp::OpEditMeshOrSubMesh,    "EDIT_MESHSUBMESH",        "ICON_DLG_EDIT_MESH" );
4127   createSMESHAction( SMESHOp::OpEditMesh,             "EDIT_MESH",               "ICON_DLG_EDIT_MESH" );
4128   createSMESHAction( SMESHOp::OpEditSubMesh,          "EDIT_SUBMESH",            "ICON_DLG_EDIT_MESH" );
4129   createSMESHAction( SMESHOp::OpBuildCompoundMesh,    "BUILD_COMPOUND",          "ICON_BUILD_COMPOUND" );
4130   createSMESHAction( SMESHOp::OpCopyMesh,             "COPY_MESH",               "ICON_COPY_MESH" );
4131   createSMESHAction( SMESHOp::OpCompute,              "COMPUTE",                 "ICON_COMPUTE" );
4132   createSMESHAction( SMESHOp::OpComputeSubMesh,       "COMPUTE_SUBMESH",         "ICON_COMPUTE" );
4133   createSMESHAction( SMESHOp::OpRecompute,            "RE_COMPUTE",              "ICON_COMPUTE" );
4134   createSMESHAction( SMESHOp::OpPreCompute,           "PRECOMPUTE",              "ICON_PRECOMPUTE" );
4135   createSMESHAction( SMESHOp::OpShowErrors,           "SHOW_ERRORS",             "ICON_SHOW_ERRORS" );
4136   createSMESHAction( SMESHOp::OpEvaluate,             "EVALUATE",                "ICON_EVALUATE" );
4137   createSMESHAction( SMESHOp::OpMeshOrder,            "MESH_ORDER",              "ICON_MESH_ORDER");
4138   createSMESHAction( SMESHOp::OpCreateGroup,          "CREATE_GROUP",            "ICON_CREATE_GROUP" );
4139   createSMESHAction( SMESHOp::OpCreateGeometryGroup,  "CREATE_GEO_GROUP",        "ICON_CREATE_GEO_GROUP" );
4140   createSMESHAction( SMESHOp::OpConstructGroup,       "CONSTRUCT_GROUP",         "ICON_CONSTRUCT_GROUP" );
4141   createSMESHAction( SMESHOp::OpEditGroup,            "EDIT_GROUP",              "ICON_EDIT_GROUP" );
4142   createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4143   createSMESHAction( SMESHOp::OpUnionGroups,          "UN_GROUP",                "ICON_UNION" );
4144   createSMESHAction( SMESHOp::OpIntersectGroups,      "INT_GROUP",               "ICON_INTERSECT" );
4145   createSMESHAction( SMESHOp::OpCutGroups,            "CUT_GROUP",               "ICON_CUT" );
4146   createSMESHAction( SMESHOp::OpGroupUnderlyingElem,  "UNDERLYING_ELEMS",        "ICON_UNDERLYING_ELEMS" );
4147   createSMESHAction( SMESHOp::OpFaceGroupsByEdges,    "FACE_GROUPS_BY_EDGES",    "ICON_FACE_GROUPS_BY_EDGES" );
4148   createSMESHAction( SMESHOp::OpAddElemGroupPopup,    "ADD_TO_GROUP" );
4149   createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4150   createSMESHAction( SMESHOp::OpDeleteGroup,          "DEL_GROUP",               "ICON_DEL_GROUP" );
4151   createSMESHAction( SMESHOp::OpMeshInformation ,     "ADV_INFO",                "ICON_ADV_INFO" );
4152   //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO",        "ICON_STD_INFO" );
4153   //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4154   createSMESHAction( SMESHOp::OpFindElementByPoint,   "FIND_ELEM",               "ICON_FIND_ELEM" );
4155   //update
4156   createSMESHAction( SMESHOp::OpFreeNode,              "FREE_NODE",               "ICON_FREE_NODE",     0, true );
4157   createSMESHAction( SMESHOp::OpEqualNode,             "EQUAL_NODE",              "ICON_EQUAL_NODE",    0, true );
4158   createSMESHAction( SMESHOp::OpNodeConnectivityNb,    "NODE_CONNECTIVITY_NB",    "ICON_NODE_CONN_NB",    0, true );
4159   createSMESHAction( SMESHOp::OpFreeEdge,              "FREE_EDGE",               "ICON_FREE_EDGE",     0, true );
4160   createSMESHAction( SMESHOp::OpFreeBorder,            "FREE_BORDER",             "ICON_FREE_EDGE_2D",  0, true );
4161   createSMESHAction( SMESHOp::OpLength,                "LENGTH",                  "ICON_LENGTH",        0, true );
4162   createSMESHAction( SMESHOp::OpConnection,            "CONNECTION",              "ICON_CONNECTION",    0, true );
4163   createSMESHAction( SMESHOp::OpEqualEdge,             "EQUAL_EDGE",              "ICON_EQUAL_EDGE",    0, true );
4164   createSMESHAction( SMESHOp::OpFreeFace,              "FREE_FACES",              "ICON_FREE_FACES",    0, true );
4165   createSMESHAction( SMESHOp::OpBareBorderFace,        "BARE_BORDER_FACE",        "ICON_BARE_BORDER_FACE",        0, true );
4166   createSMESHAction( SMESHOp::OpOverConstrainedFace,   "OVER_CONSTRAINED_FACE",   "ICON_OVER_CONSTRAINED_FACE",   0, true );
4167   createSMESHAction( SMESHOp::OpLength2D,              "LENGTH_2D",               "ICON_LENGTH_2D",     0, true );
4168   createSMESHAction( SMESHOp::OpDeflection2D,          "DEFLECTION_2D",           "ICON_DEFLECTION_2D", 0, true );
4169   createSMESHAction( SMESHOp::OpConnection2D,          "CONNECTION_2D",           "ICON_CONNECTION_2D", 0, true );
4170   createSMESHAction( SMESHOp::OpArea,                  "AREA",                    "ICON_AREA",          0, true );
4171   createSMESHAction( SMESHOp::OpTaper,                 "TAPER",                   "ICON_TAPER",         0, true );
4172   createSMESHAction( SMESHOp::OpAspectRatio,           "ASPECT",                  "ICON_ASPECT",        0, true );
4173   createSMESHAction( SMESHOp::OpMinimumAngle,          "MIN_ANG",                 "ICON_ANGLE",         0, true );
4174   createSMESHAction( SMESHOp::OpWarpingAngle,          "WARP",                    "ICON_WARP",          0, true );
4175   createSMESHAction( SMESHOp::OpSkew,                  "SKEW",                    "ICON_SKEW",          0, true );
4176   createSMESHAction( SMESHOp::OpMaxElementLength2D,    "MAX_ELEMENT_LENGTH_2D",   "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
4177   createSMESHAction( SMESHOp::OpEqualFace,             "EQUAL_FACE",              "ICON_EQUAL_FACE",    0, true );
4178   createSMESHAction( SMESHOp::OpAspectRatio3D,         "ASPECT_3D",               "ICON_ASPECT_3D",     0, true );
4179   createSMESHAction( SMESHOp::OpVolume,                "VOLUME_3D",               "ICON_VOLUME_3D",     0, true );
4180   createSMESHAction( SMESHOp::OpMaxElementLength3D,    "MAX_ELEMENT_LENGTH_3D",   "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
4181   createSMESHAction( SMESHOp::OpBareBorderVolume,      "BARE_BORDER_VOLUME",      "ICON_BARE_BORDER_VOLUME",      0, true );
4182   createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4183   createSMESHAction( SMESHOp::OpEqualVolume,           "EQUAL_VOLUME",            "ICON_EQUAL_VOLUME",  0, true );
4184   createSMESHAction( SMESHOp::OpOverallMeshQuality,    "OVERALL_MESH_QUALITY",    "ICON_OVL_MESH_QUALITY" );
4185
4186   createSMESHAction( SMESHOp::OpNode,                   "NODE",            "ICON_DLG_NODE" );
4187   createSMESHAction( SMESHOp::OpElem0D,                 "ELEM0D",          "ICON_DLG_ELEM0D" );
4188   createSMESHAction( SMESHOp::OpElem0DOnElemNodes,      "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4189   createSMESHAction( SMESHOp::OpBall,                   "BALL",            "ICON_DLG_BALL" );
4190   createSMESHAction( SMESHOp::OpEdge,                   "EDGE",            "ICON_DLG_EDGE" );
4191   createSMESHAction( SMESHOp::OpTriangle,               "TRIANGLE",        "ICON_DLG_TRIANGLE" );
4192   createSMESHAction( SMESHOp::OpQuadrangle,             "QUAD",            "ICON_DLG_QUADRANGLE" );
4193   createSMESHAction( SMESHOp::OpPolygon,                "POLYGON",         "ICON_DLG_POLYGON" );
4194   createSMESHAction( SMESHOp::OpTetrahedron,            "TETRA",           "ICON_DLG_TETRAS" );
4195   createSMESHAction( SMESHOp::OpHexahedron,             "HEXA",            "ICON_DLG_HEXAS" );
4196   createSMESHAction( SMESHOp::OpPentahedron,            "PENTA",           "ICON_DLG_PENTA" );
4197   createSMESHAction( SMESHOp::OpPyramid ,               "PYRAMID",         "ICON_DLG_PYRAMID" );
4198   createSMESHAction( SMESHOp::OpHexagonalPrism,         "OCTA",            "ICON_DLG_OCTA" );
4199   createSMESHAction( SMESHOp::OpPolyhedron,             "POLYHEDRON",      "ICON_DLG_POLYHEDRON" );
4200   createSMESHAction( SMESHOp::OpQuadraticEdge,          "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
4201   createSMESHAction( SMESHOp::OpQuadraticTriangle,      "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
4202   createSMESHAction( SMESHOp::OpBiQuadraticTriangle,    "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4203   createSMESHAction( SMESHOp::OpQuadraticQuadrangle,    "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
4204   createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle,  "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4205   createSMESHAction( SMESHOp::OpQuadraticPolygon,       "QUADRATIC_POLYGON",       "ICON_DLG_QUADRATIC_POLYGON" );
4206   createSMESHAction( SMESHOp::OpQuadraticTetrahedron,   "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4207   createSMESHAction( SMESHOp::OpQuadraticPyramid,       "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
4208   createSMESHAction( SMESHOp::OpQuadraticPentahedron,   "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4209   createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4210   createSMESHAction( SMESHOp::OpQuadraticHexahedron,    "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4211   createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4212
4213   createSMESHAction( SMESHOp::OpRemoveNodes,       "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
4214   createSMESHAction( SMESHOp::OpRemoveElements,    "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
4215   createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
4216   createSMESHAction( SMESHOp::OpClearMesh,         "CLEAR_MESH",            "ICON_CLEAR_MESH" );
4217
4218   //createSMESHAction( SMESHOp::OpRenumberingNodes,    "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
4219   //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
4220
4221   createSMESHAction( SMESHOp::OpTranslation,            "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
4222   createSMESHAction( SMESHOp::OpRotation,               "ROT",             "ICON_DLG_MESH_ROTATION" );
4223   createSMESHAction( SMESHOp::OpSymmetry,               "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
4224   createSMESHAction( SMESHOp::OpScale,                  "SCALE",           "ICON_DLG_MESH_SCALE" );
4225   createSMESHAction( SMESHOp::OpOffset,                 "OFFSET",          "ICON_DLG_MESH_OFFSET" );
4226   createSMESHAction( SMESHOp::OpSewing,                 "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
4227   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
4228   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
4229   createSMESHAction( SMESHOp::OpMoveNode,               "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4230   createSMESHAction( SMESHOp::OpDuplicateNodes,         "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4231   createSMESHAction( SMESHOp::OpDiagonalInversion,      "INV",             "ICON_DLG_MESH_DIAGONAL" );
4232   createSMESHAction( SMESHOp::OpUnionOfTwoTriangle,     "UNION2",          "ICON_UNION2TRI" );
4233   createSMESHAction( SMESHOp::OpOrientation,            "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
4234   createSMESHAction( SMESHOp::OpReorientFaces,          "REORIENT_2D",     "ICON_REORIENT_2D" );
4235   createSMESHAction( SMESHOp::OpUnionOfTriangles,       "UNION",           "ICON_UNIONTRI" );
4236   createSMESHAction( SMESHOp::OpCuttingOfQuadrangles,   "CUT",             "ICON_CUTQUAD" );
4237   createSMESHAction( SMESHOp::OpSplitVolumes,           "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
4238   createSMESHAction( SMESHOp::OpSplitBiQuadratic,       "SPLIT_BIQUAD",    "ICON_SPLIT_BIQUAD" );
4239   createSMESHAction( SMESHOp::OpSmoothing,              "SMOOTH",          "ICON_DLG_SMOOTHING" );
4240   createSMESHAction( SMESHOp::OpExtrusion,              "EXTRUSION",       "ICON_EXTRUSION" );
4241   createSMESHAction( SMESHOp::OpExtrusionAlongAPath,    "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4242   createSMESHAction( SMESHOp::OpRevolution,             "REVOLUTION",      "ICON_REVOLUTION" );
4243   createSMESHAction( SMESHOp::OpPatternMapping,         "MAP",             "ICON_MAP" );
4244   createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
4245   createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
4246
4247   createSMESHAction( SMESHOp::OpReset,               "RESET" );
4248   createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4249   createSMESHAction( SMESHOp::OpShowScalarBar,       "SHOW_SCALAR_BAR","",0, true  );
4250   createSMESHAction( SMESHOp::OpSaveDistribution,    "SAVE_DISTRIBUTION" );
4251   createSMESHAction( SMESHOp::OpShowDistribution,    "SHOW_DISTRIBUTION","",0, true );
4252 #ifndef DISABLE_PLOT2DVIEWER
4253   createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4254 #endif
4255   createSMESHAction( SMESHOp::OpDMWireframe,  "WIRE",    "ICON_WIRE", 0, true );
4256   createSMESHAction( SMESHOp::OpDMShading,    "SHADE",   "ICON_SHADE", 0, true );
4257   createSMESHAction( SMESHOp::OpDMNodes,      "NODES",   "ICON_POINTS", 0, true );
4258   createSMESHAction( SMESHOp::OpDMShrink,     "SHRINK",  "ICON_SHRINK", 0, true );
4259   createSMESHAction( SMESHOp::OpUpdate,       "UPDATE",  "ICON_UPDATE" );
4260   createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4261   createSMESHAction( SMESHOp::OpDEEdges,      "EDGES",   "ICON_DLG_EDGE", 0, true );
4262   createSMESHAction( SMESHOp::OpDEFaces,      "FACES",   "ICON_DLG_TRIANGLE", 0, true );
4263   createSMESHAction( SMESHOp::OpDEVolumes,    "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4264   createSMESHAction( SMESHOp::OpDEBalls,      "BALLS",   "ICON_DLG_BALL", 0, true );
4265   createSMESHAction( SMESHOp::OpDEChoose,     "CHOOSE",  "ICON_DLG_CHOOSE", 0, false );
4266   createSMESHAction( SMESHOp::OpDEAllEntity,  "ALL",     "ICON_DLG_CHOOSE_ALL", 0, false );
4267   createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4268
4269   createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4270   createSMESHAction( SMESHOp::OpRepresentationArcs,  "ARC_REPRESENTATION", "", 0, true );
4271
4272   createSMESHAction( SMESHOp::OpEditHypothesis,    "EDIT_HYPO" );
4273   createSMESHAction( SMESHOp::OpUnassign,          "UNASSIGN" );
4274   createSMESHAction( SMESHOp::OpNumberingNodes,    "NUM_NODES", "", 0, true );
4275   createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4276   createSMESHAction( SMESHOp::OpProperties,   "COLORS" );
4277   createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4278   createSMESHAction( SMESHOp::OpClipping,     "CLIP" );
4279   createSMESHAction( SMESHOp::OpAutoColor,        "AUTO_COLOR" );
4280   createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4281
4282   // Adaptation - begin
4283   createSMESHAction( SMESHOp::OpMGAdapt,              "MG_ADAPT",                "ICON_MG_ADAPT" );
4284   // Adaptation - end
4285
4286   createSMESHAction( SMESHOp::OpMinimumDistance,  "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4287   createSMESHAction( SMESHOp::OpBoundingBox,      "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
4288   createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH",   "ICON_MEASURE_LENGTH" );
4289   createSMESHAction( SMESHOp::OpPropertiesArea,   "MEASURE_AREA",     "ICON_MEASURE_AREA" );
4290   createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME",   "ICON_MEASURE_VOLUME" );
4291   createSMESHAction( SMESHOp::OpAngle,            "MEASURE_ANGLE",    "ICON_MEASURE_ANGLE" );
4292
4293   createSMESHAction( SMESHOp::OpHide,     "HIDE", "ICON_HIDE" );
4294   createSMESHAction( SMESHOp::OpShow,     "SHOW", "ICON_SHOW" );
4295   createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4296
4297   createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4298
4299   createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4300
4301   QList<int> aCtrlActions;
4302   aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4303                << SMESHOp::OpNodeConnectivityNb                                         // node controls
4304                << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4305                << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge    // edge controls
4306                << SMESHOp::OpDeflection2D
4307                << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4308                << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4309                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4310                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4311                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
4312                << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4313                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4314                << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
4315   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4316   aCtrlGroup->setExclusive( true );
4317   for( int i = 0; i < aCtrlActions.size(); i++ )
4318     aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4319
4320   // ----- create menu --------------
4321   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
4322       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
4323       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
4324       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
4325       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
4326       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
4327       adaptId   = createMenu( tr( "MEN_ADAPT" ),   -1, 80, 10 ),
4328       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4329       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
4330
4331   createMenu( separator(), fileId );
4332
4333   QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4334   QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4335   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4336       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4337       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4338       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4339       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4340       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4341       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
4342       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4343     //renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
4344       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4345       basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4346
4347   //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4348   createMenu( SMESHOp::OpImportUNV,  importId, -1 );
4349   createMenu( SMESHOp::OpImportMED,  importId, -1 );
4350   createMenu( SMESHOp::OpImportSTL,  importId, -1 );
4351 #ifdef WITH_CGNS
4352   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4353 #endif
4354   createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4355   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
4356   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
4357   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
4358   createMenu( SMESHOp::OpExportUNV,  exportId, -1 );
4359   createMenu( SMESHOp::OpExportSTL,  exportId, -1 );
4360 #ifdef WITH_CGNS
4361   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4362 #endif
4363   createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4364   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
4365   createMenu( separator(), fileId, 10 );
4366
4367   createMenu( SMESHOp::OpDelete, editId, -1 );
4368
4369   createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4370
4371   createMenu( SMESHOp::OpCreateMesh,           meshId, -1 ); // "Mesh" menu
4372   createMenu( SMESHOp::OpCreateSubMesh,        meshId, -1 );
4373   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
4374   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
4375   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
4376   createMenu( separator(),                     meshId, -1 );
4377   createMenu( SMESHOp::OpCompute,              meshId, -1 );
4378   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
4379   createMenu( SMESHOp::OpEvaluate,             meshId, -1 );
4380   createMenu( SMESHOp::OpMeshOrder,            meshId, -1 );
4381   createMenu( separator(),                     meshId, -1 );
4382   createMenu( SMESHOp::OpCreateGroup,          meshId, -1 );
4383   createMenu( SMESHOp::OpCreateGeometryGroup,  meshId, -1 );
4384   createMenu( SMESHOp::OpConstructGroup,       meshId, -1 );
4385   createMenu( SMESHOp::OpEditGroup,            meshId, -1 );
4386   createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4387   createMenu( separator(),                     meshId, -1 );
4388   createMenu( SMESHOp::OpUnionGroups,          meshId, -1 );
4389   createMenu( SMESHOp::OpIntersectGroups,      meshId, -1 );
4390   createMenu( SMESHOp::OpCutGroups,            meshId, -1 );
4391   createMenu( separator(),                     meshId, -1 );
4392   createMenu( SMESHOp::OpGroupUnderlyingElem,  meshId, -1 );
4393   createMenu( SMESHOp::OpFaceGroupsByEdges,    meshId, -1 );
4394   createMenu( separator(),                     meshId, -1 );
4395   createMenu( SMESHOp::OpMeshInformation,      meshId, -1 );
4396   //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4397   //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4398   createMenu( SMESHOp::OpFindElementByPoint,   meshId, -1 );
4399   createMenu( separator(),                     meshId, -1 );
4400
4401   createMenu( SMESHOp::OpFreeNode,              nodeId,   -1 );
4402   createMenu( SMESHOp::OpEqualNode,             nodeId,   -1 );
4403   //createMenu( SMESHOp::OpNodeConnectivityNb,    nodeId,   -1 );
4404   createMenu( SMESHOp::OpFreeBorder,            edgeId,   -1 );
4405   createMenu( SMESHOp::OpLength,                edgeId,   -1 );
4406   createMenu( SMESHOp::OpConnection,            edgeId,   -1 );
4407   createMenu( SMESHOp::OpEqualEdge,             edgeId,   -1 );
4408   createMenu( SMESHOp::OpFreeEdge,              faceId,   -1 );
4409   createMenu( SMESHOp::OpFreeFace,              faceId,   -1 );
4410   createMenu( SMESHOp::OpBareBorderFace,        faceId,   -1 );
4411   createMenu( SMESHOp::OpOverConstrainedFace,   faceId,   -1 );
4412   createMenu( SMESHOp::OpLength2D,              faceId,   -1 );
4413   createMenu( SMESHOp::OpConnection2D,          faceId,   -1 );
4414   createMenu( SMESHOp::OpArea,                  faceId,   -1 );
4415   createMenu( SMESHOp::OpTaper,                 faceId,   -1 );
4416   createMenu( SMESHOp::OpAspectRatio,           faceId,   -1 );
4417   createMenu( SMESHOp::OpMinimumAngle,          faceId,   -1 );
4418   createMenu( SMESHOp::OpWarpingAngle,          faceId,   -1 );
4419   createMenu( SMESHOp::OpSkew,                  faceId,   -1 );
4420   createMenu( SMESHOp::OpMaxElementLength2D,    faceId,   -1 );
4421   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
4422   createMenu( SMESHOp::OpDeflection2D,          faceId,   -1 );
4423   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
4424   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
4425   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
4426   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
4427   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4428   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
4429   createMenu( separator(),                      ctrlId,   -1 );
4430   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
4431   createMenu( separator(),                      ctrlId,   -1 );
4432   createMenu( SMESHOp::OpOverallMeshQuality,    ctrlId,   -1 );
4433
4434   createMenu( SMESHOp::OpNode,                   addId, -1 );
4435   createMenu( SMESHOp::OpElem0D,                 addId, -1 );
4436   createMenu( SMESHOp::OpElem0DOnElemNodes,      addId, -1 );
4437   createMenu( SMESHOp::OpBall,                   addId, -1 );
4438   createMenu( SMESHOp::OpEdge,                   addId, -1 );
4439   createMenu( SMESHOp::OpTriangle,               addId, -1 );
4440   createMenu( SMESHOp::OpQuadrangle,             addId, -1 );
4441   createMenu( SMESHOp::OpPolygon,                addId, -1 );
4442   createMenu( SMESHOp::OpTetrahedron,            addId, -1 );
4443   createMenu( SMESHOp::OpHexahedron,             addId, -1 );
4444   createMenu( SMESHOp::OpPentahedron,            addId, -1 );
4445   createMenu( SMESHOp::OpPyramid,                addId, -1 );
4446   createMenu( SMESHOp::OpHexagonalPrism,         addId, -1 );
4447   createMenu( SMESHOp::OpPolyhedron,             addId, -1 );
4448   createMenu( separator(),                       addId, -1 );
4449   createMenu( SMESHOp::OpQuadraticEdge,          addId, -1 );
4450   createMenu( SMESHOp::OpQuadraticTriangle,      addId, -1 );
4451   createMenu( SMESHOp::OpBiQuadraticTriangle ,   addId, -1 );
4452   createMenu( SMESHOp::OpQuadraticQuadrangle,    addId, -1 );
4453   createMenu( SMESHOp::OpBiQuadraticQuadrangle,  addId, -1 );
4454   createMenu( SMESHOp::OpQuadraticPolygon,       addId, -1 );
4455   createMenu( SMESHOp::OpQuadraticTetrahedron,   addId, -1 );
4456   createMenu( SMESHOp::OpQuadraticPyramid,       addId, -1 );
4457   createMenu( SMESHOp::OpQuadraticPentahedron,   addId, -1 );
4458   createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4459   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
4460   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4461
4462   createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
4463   createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
4464   createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4465   createMenu( separator(),                  removeId, -1 );
4466   createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
4467   createMenu( separator(),                  removeId, -1 );
4468   createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
4469
4470   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
4471   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4472
4473   createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
4474   createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
4475   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
4476   createMenu( SMESHOp::OpRotation,       transfId, -1 );
4477   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
4478   createMenu( SMESHOp::OpScale,          transfId, -1 );
4479   createMenu( SMESHOp::OpOffset,         transfId, -1 );
4480   createMenu( SMESHOp::OpSewing,         transfId, -1 );
4481   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4482
4483   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4484   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4485   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
4486   createMenu( SMESHOp::OpExtrusionAlongAPath,    modifyId, -1 );
4487   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
4488   createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
4489   createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
4490   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
4491   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
4492   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
4493   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
4494   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
4495   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
4496   createMenu( SMESHOp::OpSplitBiQuadratic,       modifyId, -1 );
4497   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
4498   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
4499
4500   // Adaptation - begin
4501   createMenu( SMESHOp::OpMGAdapt,              adaptId, -1 );
4502   // Adaptation - end
4503
4504   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
4505   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
4506   createMenu( SMESHOp::OpAngle,            measureId,   -1 );
4507   createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4508   createMenu( SMESHOp::OpPropertiesArea,   basicPropId, -1 );
4509   createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4510   createMenu( SMESHOp::OpUpdate,           viewId,      -1 );
4511
4512   connect( nodeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4513   connect( edgeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4514   connect( faceMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4515   connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4516
4517   // ----- create toolbars --------------
4518   int meshTb       = createTool( tr( "TB_MESH" ),      QString( "SMESHMeshToolbar" ) ) ;
4519   createTool( SMESHOp::OpCreateMesh,        meshTb );
4520   createTool( SMESHOp::OpCreateSubMesh,     meshTb );
4521   createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4522   createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4523   createTool( SMESHOp::OpCopyMesh,          meshTb );
4524   createTool( separator(),                  meshTb );
4525   createTool( SMESHOp::OpCompute,           meshTb );
4526   createTool( SMESHOp::OpPreCompute,        meshTb );
4527   createTool( SMESHOp::OpEvaluate,          meshTb );
4528   createTool( SMESHOp::OpMeshOrder,         meshTb );
4529
4530   int infoTb       = createTool( tr( "TB_INFO" ),      QString( "SMESHInformationToolbar" ) ) ;
4531   createTool( SMESHOp::OpMeshInformation,    infoTb );
4532   //createTool( SMESHOp::OpStdInfo, meshTb );
4533   //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4534   createTool( SMESHOp::OpFindElementByPoint, infoTb );
4535
4536   int groupTb      = createTool( tr( "TB_GROUP" ),     QString( "SMESHGroupToolbar" ) ) ;
4537   createTool( SMESHOp::OpCreateGroup,         groupTb );
4538   createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4539   createTool( SMESHOp::OpConstructGroup,      groupTb );
4540   createTool( SMESHOp::OpEditGroup,           groupTb );
4541
4542   int ctrl0dTb     = createTool( tr( "TB_CTRL0D" ),    QString( "SMESHNodeControlsToolbar" ) ) ;
4543   createTool( SMESHOp::OpFreeNode,  ctrl0dTb );
4544   createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4545   //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4546
4547   int ctrl1dTb     = createTool( tr( "TB_CTRL1D" ),    QString( "SMESHEdgeControlsToolbar" ) ) ;
4548   createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4549   createTool( SMESHOp::OpLength,     ctrl1dTb );
4550   createTool( SMESHOp::OpConnection, ctrl1dTb );
4551   createTool( SMESHOp::OpEqualEdge,  ctrl1dTb );
4552
4553   int ctrl2dTb     = createTool( tr( "TB_CTRL2D" ),    QString( "SMESHFaceControlsToolbar" ) ) ;
4554   createTool( SMESHOp::OpFreeEdge,            ctrl2dTb );
4555   createTool( SMESHOp::OpFreeFace,            ctrl2dTb );
4556   createTool( SMESHOp::OpBareBorderFace,      ctrl2dTb );
4557   createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4558   createTool( SMESHOp::OpLength2D,            ctrl2dTb );
4559   createTool( SMESHOp::OpConnection2D,        ctrl2dTb );
4560   createTool( SMESHOp::OpArea,                ctrl2dTb );
4561   createTool( SMESHOp::OpTaper,               ctrl2dTb );
4562   createTool( SMESHOp::OpAspectRatio,         ctrl2dTb );
4563   createTool( SMESHOp::OpMinimumAngle,        ctrl2dTb );
4564   createTool( SMESHOp::OpWarpingAngle,        ctrl2dTb );
4565   createTool( SMESHOp::OpSkew,                ctrl2dTb );
4566   createTool( SMESHOp::OpMaxElementLength2D,  ctrl2dTb );
4567   createTool( SMESHOp::OpEqualFace,           ctrl2dTb );
4568   createTool( SMESHOp::OpDeflection2D,        ctrl2dTb );
4569
4570   int ctrl3dTb     = createTool( tr( "TB_CTRL3D" ),    QString( "SMESHVolumeControlsToolbar" ) ) ;
4571   createTool( SMESHOp::OpAspectRatio3D,         ctrl3dTb );
4572   createTool( SMESHOp::OpVolume,                ctrl3dTb );
4573   createTool( SMESHOp::OpMaxElementLength3D,    ctrl3dTb );
4574   createTool( SMESHOp::OpBareBorderVolume,      ctrl3dTb );
4575   createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4576   createTool( SMESHOp::OpEqualVolume,           ctrl3dTb );
4577
4578   int addElemTb    = createTool( tr( "TB_ADD" ),       QString( "SMESHAddElementToolbar" ) ) ;
4579   createTool( SMESHOp::OpNode,              addElemTb );
4580   createTool( SMESHOp::OpElem0D,            addElemTb );
4581   createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4582   createTool( SMESHOp::OpBall,              addElemTb );
4583   createTool( SMESHOp::OpEdge,              addElemTb );
4584   createTool( SMESHOp::OpTriangle,          addElemTb );
4585   createTool( SMESHOp::OpQuadrangle,        addElemTb );
4586   createTool( SMESHOp::OpPolygon,           addElemTb );
4587   createTool( SMESHOp::OpTetrahedron,       addElemTb );
4588   createTool( SMESHOp::OpHexahedron,        addElemTb );
4589   createTool( SMESHOp::OpPentahedron,       addElemTb );
4590   createTool( SMESHOp::OpPyramid,           addElemTb );
4591   createTool( SMESHOp::OpHexagonalPrism,    addElemTb );
4592   createTool( SMESHOp::OpPolyhedron,        addElemTb );
4593
4594   int addNonElemTb = createTool( tr( "TB_ADDNON" ),    QString( "SMESHAddElementToolbar" ) ) ;
4595   createTool( SMESHOp::OpQuadraticEdge,          addNonElemTb );
4596   createTool( SMESHOp::OpQuadraticTriangle,      addNonElemTb );
4597   createTool( SMESHOp::OpBiQuadraticTriangle,    addNonElemTb );
4598   createTool( SMESHOp::OpQuadraticQuadrangle,    addNonElemTb );
4599   createTool( SMESHOp::OpBiQuadraticQuadrangle,  addNonElemTb );
4600   createTool( SMESHOp::OpQuadraticPolygon,       addNonElemTb );
4601   createTool( SMESHOp::OpQuadraticTetrahedron,   addNonElemTb );
4602   createTool( SMESHOp::OpQuadraticPyramid,       addNonElemTb );
4603   createTool( SMESHOp::OpQuadraticPentahedron,   addNonElemTb );
4604   createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4605   createTool( SMESHOp::OpQuadraticHexahedron,    addNonElemTb );
4606   createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4607
4608   int remTb        = createTool( tr( "TB_REM" ),       QString( "SMESHRemoveToolbar" ) ) ;
4609   createTool( SMESHOp::OpRemoveNodes,       remTb );
4610   createTool( SMESHOp::OpRemoveElements,    remTb );
4611   createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4612   createTool( SMESHOp::OpClearMesh,         remTb );
4613
4614 //   int renumbTb     = createTool( tr( "TB_RENUMBER" ),  QString( "SMESHRenumberingToolbar" ) ) ;
4615   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
4616   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4617
4618   int transformTb  = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4619   createTool( SMESHOp::OpMergeNodes,     transformTb );
4620   createTool( SMESHOp::OpMergeElements,  transformTb );
4621   createTool( SMESHOp::OpTranslation,    transformTb );
4622   createTool( SMESHOp::OpRotation,       transformTb );
4623   createTool( SMESHOp::OpSymmetry,       transformTb );
4624   createTool( SMESHOp::OpScale,          transformTb );
4625   createTool( SMESHOp::OpOffset,         transformTb );
4626   createTool( SMESHOp::OpSewing,         transformTb );
4627   createTool( SMESHOp::OpDuplicateNodes, transformTb );
4628
4629   int modifyTb     = createTool( tr( "TB_MODIFY" ),    QString( "SMESHModificationToolbar" ) ) ;
4630   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4631   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4632   createTool( SMESHOp::OpExtrusion,              modifyTb );
4633   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
4634   createTool( SMESHOp::OpRevolution,             modifyTb );
4635   createTool( SMESHOp::OpOrientation,            modifyTb );
4636   createTool( SMESHOp::OpReorientFaces,          modifyTb );
4637   createTool( SMESHOp::OpMoveNode,               modifyTb );
4638   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
4639   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
4640   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
4641   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
4642   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
4643   createTool( SMESHOp::OpSplitBiQuadratic,       modifyTb );
4644   createTool( SMESHOp::OpSmoothing,              modifyTb );
4645   createTool( SMESHOp::OpPatternMapping,         modifyTb );
4646
4647   // Adaptation - begin
4648   int adaptTb      = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ) ;
4649   createTool( SMESHOp::OpMGAdapt,              adaptTb );
4650   // Adaptation - end
4651
4652   int measuremTb   = createTool( tr( "TB_MEASUREM" ),  QString( "SMESHMeasurementsToolbar" ) ) ;
4653   createTool( SMESHOp::OpMinimumDistance, measuremTb );
4654
4655   int dispModeTb   = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4656   createTool( SMESHOp::OpUpdate, dispModeTb );
4657
4658   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4659   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4660
4661   myRules.clear();
4662   QString
4663     OB      = "'ObjectBrowser'",
4664     View    = "'" + SVTK_Viewer::Type() + "'",
4665     pat     = "'%1'",
4666     mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4667     group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4668     hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4669     algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4670     smesh   = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4671     elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4672     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4673     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4674     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4675     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4676     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4677     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4678     subMesh      = elems,
4679     mesh_part    = mesh + " " + subMesh + " " + group,
4680     mesh_group   = mesh + " " + group,
4681     mesh_submesh = mesh + " " + subMesh,
4682     hyp_alg      = hypo + " " + algo;
4683
4684   // popup for object browser
4685   QString
4686     isInvisible("not( isVisible )"),
4687     isEmpty("numberOfNodes = 0"),
4688     isNotEmpty("numberOfNodes <> 0"),
4689
4690     // has nodes, edges, etc in VISIBLE! actor
4691     hasNodes("(numberOfNodes > 0 ) && hasActor"),
4692     hasElems("(count( elemTypes ) > 0)"),
4693     hasDifferentElems("(count( elemTypes ) > 1)"),
4694     hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4695     hasBalls("({'BallElem'} in elemTypes)"),
4696     hasElems0d("({'Elem0d'} in elemTypes)"),
4697     hasEdges("({'Edge'} in elemTypes)"),
4698     hasFaces("({'Face'} in elemTypes)"),
4699     hasVolumes("({'Volume'} in elemTypes)"),
4700     hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4701
4702   createPopupItem( SMESHOp::OpEditMesh,          OB, mesh, "&& selcount=1" );
4703   createPopupItem( SMESHOp::OpCreateSubMesh,     OB, mesh, "&& hasGeomReference");
4704   createPopupItem( SMESHOp::OpMeshOrder,         OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4705   createPopupItem( SMESHOp::OpEditSubMesh,       OB, subMesh, "&& selcount=1 && hasGeomReference" );
4706   createPopupItem( SMESHOp::OpEditGroup,         OB, group );
4707   createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4708
4709   popupMgr()->insert( separator(), -1, 0 );
4710   createPopupItem( SMESHOp::OpCompute,           OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4711   createPopupItem( SMESHOp::OpRecompute,         OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4712   createPopupItem( SMESHOp::OpShowErrors,        OB, mesh, "&& selcount=1 && hasErrors" );
4713   createPopupItem( SMESHOp::OpComputeSubMesh,    OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4714   createPopupItem( SMESHOp::OpPreCompute,        OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4715   createPopupItem( SMESHOp::OpEvaluate,          OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4716   popupMgr()->insert( separator(), -1, 0 );
4717   createPopupItem( SMESHOp::OpFileInformation,   OB, mesh, "&& selcount=1 && isImported" );
4718   createPopupItem( SMESHOp::OpMeshInformation,   OB, mesh_part );
4719   createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4720   createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4721   popupMgr()->insert( separator(), -1, 0 );
4722   createPopupItem( SMESHOp::OpCreateGroup,       OB, mesh, "&& selcount=1" );
4723   createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4724   createPopupItem( SMESHOp::OpConstructGroup,    OB, subMesh );
4725   popupMgr()->insert( separator(), -1, 0 );
4726   createPopupItem( SMESHOp::OpEditHypothesis,    OB, hypo, "&& isEditableHyp");
4727   createPopupItem( SMESHOp::OpUnassign,          OB, hyp_alg );
4728   popupMgr()->insert( separator(), -1, 0 );
4729   createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4730   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4731   popupMgr()->insert( separator(), -1, 0 );
4732
4733   // Adaptation - begin
4734   createPopupItem( SMESHOp::OpMGAdapt,              OB, mesh );
4735   // Adaptation - end
4736
4737   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4738   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4739   QString only_one_2D        = only_one_non_empty + " && dim>1";
4740
4741   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4742   popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4743   createPopupItem( SMESHOp::OpPopupExportMED,  OB, mesh_group, multiple_non_empty, anId );
4744   createPopupItem( SMESHOp::OpPopupExportUNV,  OB, mesh_group, only_one_non_empty, anId );
4745   createPopupItem( SMESHOp::OpPopupExportSTL,  OB, mesh_group, only_one_2D, anId );
4746 #ifdef WITH_CGNS
4747   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4748 #endif
4749   createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4750   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, only_one_non_empty, anId );
4751   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, only_one_non_empty, anId );
4752
4753   anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 );        // IMPORT submenu
4754   createPopupItem( SMESHOp::OpPopupImportMED,  OB, smesh, "", anId );
4755   createPopupItem( SMESHOp::OpPopupImportUNV,  OB, smesh, "", anId );
4756   createPopupItem( SMESHOp::OpPopupImportSTL,  OB, smesh, "", anId );
4757 #ifdef WITH_CGNS
4758   createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4759 #endif
4760   createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4761   createPopupItem( SMESHOp::OpPopupImportGMF,  OB, smesh, "", anId );
4762   createPopupItem( SMESHOp::OpPopupImportDAT,  OB, smesh, "", anId );
4763   popupMgr()->insert( separator(), -1, 0 );
4764
4765   createPopupItem( SMESHOp::OpClearMesh,         OB, mesh );
4766   createPopupItem( SMESHOp::OpDelete,            OB, mesh_part + " " + hyp_alg );
4767   createPopupItem( SMESHOp::OpDeleteGroup,       OB, group );
4768
4769   // popup for viewer
4770   createPopupItem( SMESHOp::OpEditGroup,            View, group );
4771   createPopupItem( SMESHOp::OpAddElemGroupPopup,    View, elems, "&& guiState = 800" );
4772   createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4773
4774   popupMgr()->insert( separator(), -1, 0 );
4775   createPopupItem( SMESHOp::OpMeshInformation,    View, mesh_part );
4776   createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4777   createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4778   popupMgr()->insert( separator(), -1, 0 );
4779
4780   createPopupItem( SMESHOp::OpUpdate,           OB + " " + View, mesh_part );
4781   createPopupItem( SMESHOp::OpAutoColor,        OB + " " + View, mesh, "&& (not isAutoColor)" );
4782   createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4783   popupMgr()->insert( separator(), -1, 0 );
4784
4785   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4786   QString aType = QString( "%1type in {%2}" ).arg( lc );
4787   aType = aType.arg( mesh_part );
4788   QString aMeshInVTK = aClient + "&&" + aType;
4789
4790   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4791   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4792   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4793
4794   //-------------------------------------------------
4795   // Numbering
4796   //-------------------------------------------------
4797   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4798
4799   popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4800   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4801   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4802
4803   popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4804   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4805   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4806
4807   popupMgr()->insert( separator(), -1, -1 );
4808
4809   //-------------------------------------------------
4810   // Display Mode
4811   //-------------------------------------------------
4812   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4813
4814   popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4815   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4816   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4817
4818   popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4819   popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4820   popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4821
4822   popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4823   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4824   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4825
4826   popupMgr()->insert( separator(), anId, -1 );
4827
4828   popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4829   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4830   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4831
4832   //-------------------------------------------------
4833   // Display Entity
4834   //-------------------------------------------------
4835   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4836
4837   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4838
4839   popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4840   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4841   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4842
4843   popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4844   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4845   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4846
4847   popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4848   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4849   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4850
4851   popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4852   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4853   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4854
4855   popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4856   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4857   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4858
4859   popupMgr()->insert( separator(), anId, -1 );
4860
4861   popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4862   popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4863
4864   popupMgr()->insert( separator(), anId, -1 );
4865
4866   popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4867   popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4868
4869
4870   //-------------------------------------------------
4871   // Representation of the 2D Quadratic elements
4872   //-------------------------------------------------
4873   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4874   popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4875   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4876   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4877
4878   popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4879   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4880   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4881
4882   //-------------------------------------------------
4883   // Orientation of faces
4884   //-------------------------------------------------
4885   popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4886   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4887   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4888
4889   //-------------------------------------------------
4890   // Color / Size
4891   //-------------------------------------------------
4892   popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4893   popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4894
4895   //-------------------------------------------------
4896   // Transparency
4897   //-------------------------------------------------
4898   popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4899   popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4900
4901   //-------------------------------------------------
4902   // Controls
4903   //-------------------------------------------------
4904   QString
4905     aMeshInVtkHasNodes   = aMeshInVTK + "&&" + hasNodes,
4906     aMeshInVtkHasEdges   = aMeshInVTK + "&&" + hasEdges,
4907     aMeshInVtkHasFaces   = aMeshInVTK + "&&" + hasFaces,
4908     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4909
4910   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4911
4912   popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4913   popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4914
4915   popupMgr()->insert( separator(), anId, -1 );
4916
4917   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4918
4919   popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4920   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4921   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4922
4923   popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4924   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4925   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4926
4927   // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4928   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4929   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4930
4931   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4932
4933   popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4934   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4935   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4936
4937   popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4938   popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4939   popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4940
4941   popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4942   popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4943   popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4944   popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4945   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4946   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4947
4948   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4949
4950   popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4951   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4952   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4953
4954   popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4955   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4956                                        QtxPopupMgr::VisibleRule );
4957   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4958
4959   popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4960   popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4961   popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4962
4963   popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4964   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4965   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4966
4967   popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4968   popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4969   popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4970
4971   popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4972   popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4973   popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4974
4975   popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4976   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4977   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4978
4979   popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4980   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4981   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4982
4983   popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4984   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4985   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4986
4987   popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4988   popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4989   popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4990
4991   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4992   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4993   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4994
4995   popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4996   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4997   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4998
4999   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5000   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5001   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5002
5003   popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5004   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5005   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5006
5007   popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5008   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5009   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5010
5011   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5012
5013   popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D  ), aSubId, -1 );
5014   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5015   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5016
5017   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5018   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5019   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5020
5021   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5022   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5023   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5024
5025   popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5026   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5027   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5028
5029   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5030   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5031   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5032
5033   popupMgr()->insert ( action( SMESHOp::OpEqualVolume  ), aSubId, -1 );
5034   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5035   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5036
5037   popupMgr()->insert( separator(), anId, -1 );
5038
5039   popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5040   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5041   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5042   popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5043   popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5044
5045   popupMgr()->insert( separator(), anId, -1 );
5046
5047   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5048
5049   popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5050   popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5051
5052   popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5053   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5054   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5055
5056 #ifndef DISABLE_PLOT2DVIEWER
5057   popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5058   popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5059 #endif
5060
5061   //-------------------------------------------------
5062   // Show / Hide
5063   //-------------------------------------------------
5064   popupMgr()->insert( separator(), -1, -1 );
5065   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5066     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5067   popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5068   popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5069
5070   popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5071   popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5072
5073   popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5074   popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5075
5076   popupMgr()->insert( separator(), -1, -1 );
5077
5078   //-------------------------------------------------
5079   // Clipping
5080   //-------------------------------------------------
5081   popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5082   popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5083
5084   popupMgr()->insert( separator(), -1, -1 );
5085
5086   popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5087   popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5088   popupMgr()->insert( separator(), -1, -1 );
5089
5090   popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5091   popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5092
5093   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5094            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5095
5096   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5097            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5098 }
5099
5100 //================================================================================
5101 /*!
5102  * \brief Return true if SMESH or GEOM objects are selected.
5103  * Is called form LightApp_Module::activateModule() which clear selection if
5104  * not isSelectionCompatible()
5105  */
5106 //================================================================================
5107
5108 bool SMESHGUI::isSelectionCompatible()
5109 {
5110   bool isCompatible = true;
5111   SALOME_ListIO selected;
5112   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5113     Sel->selectedObjects( selected );
5114
5115   SALOME_ListIteratorOfListIO It( selected );
5116   for ( ; isCompatible && It.More(); It.Next())
5117     isCompatible =
5118       ( strcmp("GEOM",        It.Value()->getComponentDataType()) == 0 ) ||
5119       ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5120       ( strcmp("SMESH",       It.Value()->getComponentDataType()) == 0 );
5121
5122   return isCompatible;
5123 }
5124
5125
5126 bool SMESHGUI::reusableOperation( const int id )
5127 {
5128   // compute, evaluate and precompute are not reusable operations
5129   return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5130 }
5131
5132 namespace
5133 {
5134   QString wrap(const QString& text, const QString& tag)
5135   { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5136 }
5137
5138 bool SMESHGUI::activateModule( SUIT_Study* study )
5139 {
5140   bool res = SalomeApp_Module::activateModule( study );
5141
5142   setMenuShown( true );
5143   setToolShown( true );
5144
5145   // Fill in Help Panel
5146   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5147   app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5148
5149   int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5150   QString lab;
5151   QStringList items;
5152   lab =       tr("INFO_DEFINE_ALGOS") + "<br/>";
5153   lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5154   lab = lab + tr("INFO_COMPUTE") + "<br/>";
5155   lab = lab + tr("INFO_REFINE") + ":";
5156   items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5157         << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5158   lab = lab + wrap(items.join(""), "ul");
5159   items.clear();
5160
5161   app->infoPanel()->addLabel(lab, gb);
5162
5163   gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5164   items << wrap("UNV", "li")
5165         << wrap("MED", "li")
5166         << wrap("STL", "li")
5167         << wrap("CGNS", "li")
5168         << wrap("SAUV", "li")
5169         << wrap("GMF", "li");
5170   lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5171   items.clear();
5172
5173   app->infoPanel()->addLabel(lab, gb);
5174
5175   gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5176   lab = tr("INFO_DISPLAY") + "<br/>";
5177   items << wrap(tr("INFO_QUALITY_AREA"), "li")
5178         << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5179         << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5180         << wrap("...", "li");
5181   lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5182   items.clear();
5183   lab = lab + tr("INFO_CLIPPING");
5184
5185   app->infoPanel()->addLabel(lab, gb);
5186   // << Help Panel
5187
5188   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5189   PyGILState_STATE gstate = PyGILState_Ensure();
5190   PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5191   if ( !pluginsmanager ) {
5192     PyErr_Print();
5193   }
5194   else {
5195     PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5196     if ( !result )
5197       PyErr_Print();
5198     Py_XDECREF(result);
5199   }
5200   PyGILState_Release(gstate);
5201   // end of SMESH plugins loading
5202
5203   // Reset actions accelerator keys
5204   action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5205
5206   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5207   GetSMESHGen()->UpdateStudy();
5208
5209   // get all view currently opened in the study and connect their signals  to
5210   // the corresponding slots of the class.
5211   SUIT_Desktop* aDesk = study->application()->desktop();
5212   if ( aDesk ) {
5213     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5214     SUIT_ViewWindow* wnd;
5215     foreach ( wnd, wndList )
5216     {
5217       connectView( wnd );
5218
5219       // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5220       SMESH::UpdateActorsAfterUpdateStudy(wnd);
5221
5222       wnd->update();
5223     }
5224   }
5225
5226   Py_XDECREF(pluginsmanager);
5227   return res;
5228 }
5229
5230 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5231 {
5232   setMenuShown( false );
5233   setToolShown( false );
5234
5235   EmitSignalCloseAllDialogs();
5236
5237   // Unset actions accelerator keys
5238   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5239
5240   return SalomeApp_Module::deactivateModule( study );
5241 }
5242
5243 void SMESHGUI::studyClosed( SUIT_Study* s )
5244 {
5245   if( !s )
5246     return;
5247   SMESH::RemoveVisuData();
5248   SalomeApp_Module::studyClosed( s );
5249 }
5250
5251 void SMESHGUI::OnGUIEvent()
5252 {
5253   const QObject* obj = sender();
5254   if ( !obj || !obj->inherits( "QAction" ) )
5255     return;
5256   int id = actionId((QAction*)obj);
5257   if ( id != -1 )
5258     OnGUIEvent( id );
5259 }
5260
5261 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5262 {
5263   if ( CORBA::is_nil( myComponentSMESH ) )
5264   {
5265     SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5266     return aGUI.myComponentSMESH;
5267   }
5268   return myComponentSMESH;
5269 }
5270
5271 QString SMESHGUI::engineIOR() const
5272 {
5273   CORBA::ORB_var anORB = getApp()->orb();
5274   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5275   return QString( anIOR.in() );
5276 }
5277
5278 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5279 {
5280   SalomeApp_Module::contextMenuPopup( client, menu, title );
5281   SALOME_ListIO lst;
5282   selectionMgr()->selectedObjects( lst );
5283   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5284     Handle(SALOME_InteractiveObject) io = lst.First();
5285     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5286     _PTR(Study) study = appStudy->studyDS();
5287     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5288     if ( obj ) {
5289       QString aName = SMESH::fromUtf8( obj->GetName());
5290       while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5291         aName.remove(( aName.length() - 1 ), 1 );
5292       title = aName;
5293     }
5294   }
5295 }
5296
5297 LightApp_Selection* SMESHGUI::createSelection() const
5298 {
5299   return new SMESHGUI_Selection();
5300 }
5301
5302 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5303 {
5304   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5305   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5306   aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5307 #ifndef DISABLE_PYCONSOLE
5308   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5309 #endif
5310 }
5311
5312 void SMESHGUI::viewManagers( QStringList& list ) const
5313 {
5314   list.append( SVTK_Viewer::Type() );
5315 }
5316
5317 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5318 {
5319   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5320     SMESH::UpdateSelectionProp( this );
5321
5322     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5323     for(int i = 0; i < aViews.count() ; i++){
5324       SUIT_ViewWindow *sf = aViews[i];
5325       connectView( sf );
5326     }
5327     EmitSignalActivatedViewManager();
5328   }
5329 }
5330
5331 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5332 {
5333   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5334     myClippingPlaneInfoMap.erase( theViewManager );
5335 }
5336
5337 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5338 {
5339   theActor->AddObserver( SMESH::DeleteActorEvent,
5340                          myEventCallbackCommand.GetPointer(),
5341                          myPriority );
5342 }
5343
5344 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5345                               unsigned long theEvent,
5346                               void* theClientData,
5347                               void* /*theCallData*/ )
5348 {
5349   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5350     if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5351       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5352         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5353         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5354         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5355           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5356           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5357           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5358             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5359             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5360             SMESH::TActorList::iterator anIter3 = anActorList.begin();
5361             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5362               if( anActor == *anIter3 ) {
5363                 anActorList.erase( anIter3 );
5364                 break;
5365               }
5366             }
5367           }
5368         }
5369       }
5370     }
5371   }
5372 }
5373
5374 void SMESHGUI::createPreferences()
5375 {
5376   // General tab ------------------------------------------------------------------------
5377   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5378
5379   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5380   setPreferenceProperty( autoUpdate, "columns", 2 );
5381   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5382   setPreferenceProperty( lim, "min",  0 );
5383   setPreferenceProperty( lim, "max",  100000000 );
5384   setPreferenceProperty( lim, "step", 1000 );
5385   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5386   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5387
5388   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5389   setPreferenceProperty( dispgroup, "columns", 2 );
5390
5391   addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5392
5393   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5394   QStringList modes;
5395   modes.append( tr("MEN_WIRE") );
5396   modes.append( tr("MEN_SHADE") );
5397   modes.append( tr("MEN_NODES") );
5398   modes.append( tr("MEN_SHRINK") );
5399   QList<QVariant> indices;
5400   indices.append( 0 );
5401   indices.append( 1 );
5402   indices.append( 2 );
5403   indices.append( 3 );
5404   setPreferenceProperty( dispmode, "strings", modes );
5405   setPreferenceProperty( dispmode, "indexes", indices );
5406
5407   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5408   setPreferenceProperty( arcgroup, "columns", 2 );
5409   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5410   QStringList quadraticModes;
5411   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5412   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5413   indices.clear();
5414   indices.append( 0 );
5415   indices.append( 1 );
5416   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5417   setPreferenceProperty( quadraticmode, "indexes", indices );
5418
5419   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5420                               "SMESH", "max_angle" );
5421   setPreferenceProperty( maxAngle, "min", 1 );
5422   setPreferenceProperty( maxAngle, "max", 90 );
5423
5424   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5425   setPreferenceProperty( qaGroup, "columns", 2 );
5426   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5427   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5428   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5429   setPreferenceProperty( prec, "min", 0 );
5430   setPreferenceProperty( prec, "max", 100 );
5431   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5432   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5433   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5434   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5435   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5436
5437   /*
5438   int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5439   setPreferenceProperty( cinc, "min", 0 );
5440   setPreferenceProperty( cinc, "max", 5 );
5441   */
5442
5443   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5444   setPreferenceProperty( exportgroup, "columns", 2 );
5445   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5446   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5447   int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5448   setPreferenceProperty( zTol, "precision", 10 );
5449   setPreferenceProperty( zTol, "min", 0.0000000001 );
5450   setPreferenceProperty( zTol, "max", 1000000.0 );
5451   setPreferenceProperty( zTol, "step", 1. );
5452   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5453
5454   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5455   setPreferenceProperty( computeGroup, "columns", 2 );
5456   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5457   modes.clear();
5458   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5459   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5460   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5461   indices.clear();
5462   indices.append( 0 );
5463   indices.append( 1 );
5464   indices.append( 2 );
5465   setPreferenceProperty( notifyMode, "strings", modes );
5466   setPreferenceProperty( notifyMode, "indexes", indices );
5467
5468   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5469   setPreferenceProperty( infoGroup, "columns", 2 );
5470   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5471   modes.clear();
5472   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5473   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5474   indices.clear();
5475   indices.append( 0 );
5476   indices.append( 1 );
5477   setPreferenceProperty( elemInfo, "strings", modes );
5478   setPreferenceProperty( elemInfo, "indexes", indices );
5479   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5480   setPreferenceProperty( nodesLim, "min", 0 );
5481   setPreferenceProperty( nodesLim, "max", 10000000 );
5482   setPreferenceProperty( nodesLim, "step", 10000 );
5483   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5484   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5485   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5486   setPreferenceProperty( ctrlLim, "min", 0 );
5487   setPreferenceProperty( ctrlLim, "max", 10000000 );
5488   setPreferenceProperty( ctrlLim, "step", 1000 );
5489   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5490   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5491   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5492   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5493   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5494
5495   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5496   setPreferenceProperty( segGroup, "columns", 2 );
5497   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5498                               "SMESH", "segmentation" );
5499   setPreferenceProperty( segLen, "min", 1 );
5500   setPreferenceProperty( segLen, "max", 10000000 );
5501   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5502                              "SMESH", "nb_segments_per_edge" );
5503   setPreferenceProperty( nbSeg, "min", 1 );
5504   setPreferenceProperty( nbSeg, "max", 10000000 );
5505   addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5506
5507   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5508   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5509                  "SMESH", "forget_mesh_on_hyp_modif" );
5510
5511
5512   // Quantities with individual precision settings
5513   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5514   setPreferenceProperty( precGroup, "columns", 2 );
5515
5516   const int nbQuantities = 6;
5517   int precs[nbQuantities], ii = 0;
5518   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5519                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5520   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5521                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5522   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5523                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5524   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5525                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5526   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5527                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5528   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5529                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5530
5531   // Set property for precision value for spinboxes
5532   for ( ii = 0; ii < nbQuantities; ii++ ){
5533     setPreferenceProperty( precs[ii], "min", -14 );
5534     setPreferenceProperty( precs[ii], "max", 14 );
5535     setPreferenceProperty( precs[ii], "precision", 2 );
5536   }
5537
5538   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5539   setPreferenceProperty( previewGroup, "columns", 2 );
5540   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5541   setPreferenceProperty( chunkSize, "min",  1 );
5542   setPreferenceProperty( chunkSize, "max",  1000 );
5543   setPreferenceProperty( chunkSize, "step", 50 );
5544
5545   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5546   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5547
5548   // Mesh tab ------------------------------------------------------------------------
5549   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5550   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5551   setPreferenceProperty( nodeGroup, "columns", 3 );
5552
5553   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5554
5555   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5556
5557   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5558   QList<QVariant> aMarkerTypeIndicesList;
5559   QList<QVariant> aMarkerTypeIconsList;
5560   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5561     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5562     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5563     aMarkerTypeIndicesList << i;
5564     aMarkerTypeIconsList << pixmap;
5565   }
5566   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5567   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5568
5569   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5570
5571   QList<QVariant> aMarkerScaleIndicesList;
5572   QStringList     aMarkerScaleValuesList;
5573   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5574     aMarkerScaleIndicesList << i;
5575     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5576     aMarkerScaleValuesList  << QString::number( i );
5577   }
5578   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5579   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5580
5581   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5582   //setPreferenceProperty( elemGroup, "columns", 2 );
5583
5584   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5585   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5586   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5587   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5588   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5589   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5590   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5591   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5592   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5593
5594
5595   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5596   setPreferenceProperty( grpGroup, "columns", 2 );
5597
5598   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5599   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5600
5601   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5602                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5603   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5604                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5605   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5606                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5607   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5608                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5609   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5610                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5611   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5612                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5613   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5614                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5615
5616   setPreferenceProperty( size0d, "min", 1 );
5617   setPreferenceProperty( size0d, "max", 10 );
5618
5619  // setPreferenceProperty( ballSize, "min", 1 );
5620  // setPreferenceProperty( ballSize, "max", 10 );
5621
5622   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5623   setPreferenceProperty( ballDiameter, "max", 1e9 );
5624   setPreferenceProperty( ballDiameter, "step", 0.1 );
5625
5626   setPreferenceProperty( ballScale, "min", 1e-2 );
5627   setPreferenceProperty( ballScale, "max", 1e7 );
5628   setPreferenceProperty( ballScale, "step", 0.5 );
5629
5630   setPreferenceProperty( elemW, "min", 1 );
5631   setPreferenceProperty( elemW, "max", 5 );
5632
5633   setPreferenceProperty( outW, "min", 1 );
5634   setPreferenceProperty( outW, "max", 5 );
5635
5636   setPreferenceProperty( shrink, "min", 0 );
5637   setPreferenceProperty( shrink, "max", 100 );
5638
5639   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5640   setPreferenceProperty( numGroup, "columns", 2 );
5641
5642   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5643   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5644
5645   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5646   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5647
5648   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5649   setPreferenceProperty( orientGroup, "columns", 1 );
5650
5651   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5652   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5653
5654   setPreferenceProperty( orientScale, "min", 0.05 );
5655   setPreferenceProperty( orientScale, "max", 0.5 );
5656   setPreferenceProperty( orientScale, "step", 0.05 );
5657
5658   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5659
5660   // Selection tab ------------------------------------------------------------------------
5661   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5662
5663   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5664   setPreferenceProperty( selGroup, "columns", 2 );
5665
5666   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5667   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5668
5669   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5670   setPreferenceProperty( preGroup, "columns", 2 );
5671
5672   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5673
5674   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5675   setPreferenceProperty( precSelGroup, "columns", 2 );
5676
5677   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5678   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5679   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5680
5681   int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5682   setPreferenceProperty( sinc, "min", 0 );
5683   setPreferenceProperty( sinc, "max", 5 );
5684
5685   // Scalar Bar tab ------------------------------------------------------------------------
5686   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5687   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5688   setPreferenceProperty( fontGr, "columns", 2 );
5689
5690   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5691   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5692
5693   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5694   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5695
5696   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5697   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5698
5699   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5700   setPreferenceProperty( numcol, "min", 2 );
5701   setPreferenceProperty( numcol, "max", 256 );
5702
5703   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5704   setPreferenceProperty( numlab, "min", 2 );
5705   setPreferenceProperty( numlab, "max", 65 );
5706
5707   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5708   setPreferenceProperty( orientGr, "columns", 2 );
5709   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5710   QStringList orients;
5711   orients.append( tr( "SMESH_VERTICAL" ) );
5712   orients.append( tr( "SMESH_HORIZONTAL" ) );
5713   indices.clear(); indices.append( 0 ); indices.append( 1 );
5714   setPreferenceProperty( orient, "strings", orients );
5715   setPreferenceProperty( orient, "indexes", indices );
5716
5717   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5718   setPreferenceProperty( posVSizeGr, "columns", 2 );
5719   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5720   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5721   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5722   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5723   setPreferenceProperty( xv, "step", 0.1 );
5724   setPreferenceProperty( xv, "min", 0.0 );
5725   setPreferenceProperty( xv, "max", 1.0 );
5726   setPreferenceProperty( yv, "step", 0.1 );
5727   setPreferenceProperty( yv, "min", 0.0 );
5728   setPreferenceProperty( yv, "max", 1.0 );
5729   setPreferenceProperty( wv, "step", 0.1 );
5730   setPreferenceProperty( wv, "min", 0.0 );
5731   setPreferenceProperty( wv, "max", 1.0 );
5732   setPreferenceProperty( hv, "min", 0.0 );
5733   setPreferenceProperty( hv, "max", 1.0 );
5734   setPreferenceProperty( hv, "step", 0.1 );
5735
5736   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5737   setPreferenceProperty( posHSizeGr, "columns", 2 );
5738   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5739   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5740   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5741   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5742   setPreferenceProperty( xv, "min", 0.0 );
5743   setPreferenceProperty( xv, "max", 1.0 );
5744   setPreferenceProperty( xv, "step", 0.1 );
5745   setPreferenceProperty( xh, "min", 0.0 );
5746   setPreferenceProperty( xh, "max", 1.0 );
5747   setPreferenceProperty( xh, "step", 0.1 );
5748   setPreferenceProperty( yh, "min", 0.0 );
5749   setPreferenceProperty( yh, "max", 1.0 );
5750   setPreferenceProperty( yh, "step", 0.1 );
5751   setPreferenceProperty( wh, "min", 0.0 );
5752   setPreferenceProperty( wh, "max", 1.0 );
5753   setPreferenceProperty( wh, "step", 0.1 );
5754   setPreferenceProperty( hh, "min", 0.0 );
5755   setPreferenceProperty( hh, "max", 1.0 );
5756   setPreferenceProperty( hh, "step", 0.1 );
5757
5758   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5759   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5760   setPreferenceProperty( distributionGr, "columns", 3 );
5761   QStringList types;
5762   types.append( tr( "SMESH_MONOCOLOR" ) );
5763   types.append( tr( "SMESH_MULTICOLOR" ) );
5764   indices.clear(); indices.append( 0 ); indices.append( 1 );
5765   setPreferenceProperty( coloringType, "strings", types );
5766   setPreferenceProperty( coloringType, "indexes", indices );
5767   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5768
5769   // Adaptation - begin
5770   // Adaptation tab ------------------------------------------------------------------------
5771   int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5772   int bloc, pref ;
5773   // MG-Adapt
5774   bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5775   setPreferenceProperty( bloc, "columns", 1 );
5776   pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5777   pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5778   pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5779   QStringList aListOfSizeMap;
5780   aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5781   aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5782   aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5783   setPreferenceProperty( pref, "strings", aListOfSizeMap );
5784   pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5785   QStringList aListOfTimeStep;
5786   aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5787   aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5788   aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5789   setPreferenceProperty( pref, "strings", aListOfTimeStep );
5790   // Adaptation - end
5791
5792 }
5793
5794 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5795 {
5796   if ( sect=="SMESH" ) {
5797     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5798     float aTol = 1.00000009999999;
5799     std::string aWarning;
5800     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5801
5802     if ( name ==  "selection_object_color" ||
5803          name == "selection_element_color" ||
5804          name ==         "highlight_color" ||
5805          name == "selection_precision_node"    ||
5806          name == "selection_precision_element" ||
5807          name == "selection_precision_object"  ||
5808          name == "selection_increment")
5809     {
5810       SMESH::UpdateSelectionProp( this );
5811     }
5812     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5813     {
5814       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5815       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5816       if ( sbX1+sbW > aTol ) {
5817         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5818         sbX1 = 0.01;
5819         sbW  = 0.08;
5820         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5821         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5822       }
5823     }
5824     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5825     {
5826       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5827       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5828       if ( sbY1 + sbH > aTol ) {
5829         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5830         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5831         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5832       }
5833     }
5834     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5835     {
5836       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5837       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5838       if ( sbX1 + sbW > aTol ) {
5839         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5840         sbX1=0.1;
5841         sbW =0.08;
5842         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5843         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5844       }
5845     }
5846     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5847     {
5848       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5849       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5850       if ( sbY1 + sbH > aTol ) {
5851         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5852         sbY1=0.01;
5853         sbH =0.08;
5854         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5855         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5856       }
5857     }
5858     else if ( name == "segmentation" )
5859     {
5860       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5861       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5862     }
5863     else if ( name == "nb_segments_per_edge" )
5864     {
5865       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5866       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5867     }
5868     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5869     {
5870       QString val = aResourceMgr->stringValue( "SMESH", name );
5871       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5872     }
5873     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5874     {
5875       SMESH::UpdateFontProp( this );
5876     }
5877     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5878     {
5879       SMESH::UpdateFontProp( this );
5880     }
5881
5882     if ( aWarning.size() != 0 ) {
5883       aWarning += "The default values are applied instead.";
5884       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5885                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5886                                QObject::tr(aWarning.c_str()));
5887     }
5888   }
5889 }
5890
5891 //================================================================================
5892 /*!
5893  * \brief Update something in accordance with update flags
5894   * \param theFlags - update flags
5895 *
5896 * Update viewer or/and object browser etc. in accordance with update flags ( see
5897 * LightApp_UpdateFlags enumeration ).
5898 */
5899 //================================================================================
5900 void SMESHGUI::update( const int flags )
5901 {
5902   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5903     SMESH::UpdateView();
5904   else
5905     SalomeApp_Module::update( flags );
5906 }
5907
5908 //================================================================================
5909 /*!
5910  * \brief Set default selection mode
5911 *
5912 * SLOT called when operation committed. Sets default selection mode
5913 */
5914 //================================================================================
5915 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5916 {
5917   SVTK_ViewWindow* vtkWnd =
5918     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5919   if ( vtkWnd )
5920     vtkWnd->SetSelectionMode( ActorSelection );
5921 }
5922
5923 //================================================================================
5924 /*!
5925  * \brief Set default selection mode
5926 *
5927 * SLOT called when operation aborted. Sets default selection mode
5928 */
5929 //================================================================================
5930 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5931 {
5932   SVTK_ViewWindow* vtkWnd =
5933     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5934   if ( vtkWnd )
5935     vtkWnd->SetSelectionMode( ActorSelection );
5936 }
5937
5938 //================================================================================
5939 /*!
5940  * \brief Creates operation with given identifier
5941   * \param id - identifier of operation to be started
5942   * \return Pointer on created operation or NULL if operation is not created
5943 *
5944 * Virtual method redefined from the base class creates operation with given id.
5945 * It is called called automatically from startOperation method of base class.
5946 */
5947 //================================================================================
5948 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5949 {
5950   LightApp_Operation* op = 0;
5951   // to do : create operation here
5952   switch( id )
5953   {
5954   case SMESHOp::OpSplitBiQuadratic:
5955     op = new SMESHGUI_SplitBiQuadOp();
5956     break;
5957   case SMESHOp::OpConvertMeshToQuadratic:
5958     op = new SMESHGUI_ConvToQuadOp();
5959     break;
5960   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5961     op = new SMESHGUI_Make2DFrom3DOp();
5962     break;
5963   case SMESHOp::OpReorientFaces:
5964     op = new SMESHGUI_ReorientFacesOp();
5965     break;
5966   case SMESHOp::OpCreateMesh:
5967     op = new SMESHGUI_MeshOp( true, true );
5968     break;
5969   case SMESHOp::OpCreateSubMesh:
5970     op = new SMESHGUI_MeshOp( true, false );
5971     break;
5972   case SMESHOp::OpEditMeshOrSubMesh:
5973   case SMESHOp::OpEditMesh:
5974   case SMESHOp::OpEditSubMesh:
5975     op = new SMESHGUI_MeshOp( false );
5976     break;
5977   case SMESHOp::OpCompute:
5978   case SMESHOp::OpComputeSubMesh:
5979     op = new SMESHGUI_ComputeOp();
5980     break;
5981   case SMESHOp::OpShowErrors:
5982     op = new SMESHGUI_ShowErrorsOp();
5983     break;
5984   case SMESHOp::OpPreCompute:
5985     op = new SMESHGUI_PrecomputeOp();
5986     break;
5987   case SMESHOp::OpEvaluate:
5988     op = new SMESHGUI_EvaluateOp();
5989     break;
5990   case SMESHOp::OpMeshOrder:
5991     op = new SMESHGUI_MeshOrderOp();
5992     break;
5993   case SMESHOp::OpCreateGeometryGroup:
5994     op = new SMESHGUI_GroupOnShapeOp();
5995     break;
5996   case SMESHOp::OpFindElementByPoint:
5997     op = new SMESHGUI_FindElemByPointOp();
5998     break;
5999   case SMESHOp::OpMoveNode: // Make mesh pass through point
6000     op = new SMESHGUI_MakeNodeAtPointOp();
6001     break;
6002   case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6003     op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6004     break;
6005   // Adaptation - begin
6006   case SMESHOp::OpMGAdapt:
6007     break;
6008   // Adaptation - end
6009   default:
6010     break;
6011   }
6012
6013   if( !op )
6014     op = SalomeApp_Module::createOperation( id );
6015   return op;
6016 }
6017
6018 //================================================================================
6019 /*!
6020  * \brief Stops current operations and starts a given one
6021   * \param id - The id of the operation to start
6022  */
6023 //================================================================================
6024
6025 void SMESHGUI::switchToOperation(int id)
6026 {
6027   activeStudy()->abortAllOperations();
6028   startOperation( id );
6029 }
6030
6031 LightApp_Displayer* SMESHGUI::displayer()
6032 {
6033   if( !myDisplayer )
6034     myDisplayer = new SMESHGUI_Displayer( getApp() );
6035   return myDisplayer;
6036 }
6037
6038 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6039 {
6040   int aHue = -1;
6041   int aTolerance = 64;
6042   int anIterations = 0;
6043   int aPeriod = 5;
6044
6045   while( 1 )
6046   {
6047     anIterations++;
6048     if( anIterations % aPeriod == 0 )
6049     {
6050       aTolerance /= 2;
6051       if( aTolerance < 1 )
6052         break;
6053     }
6054
6055     aHue = (int)( 360.0 * rand() / RAND_MAX );
6056
6057     bool ok = true;
6058     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6059     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6060     for( ; it != itEnd; ++it )
6061     {
6062       SALOMEDS::Color anAutoColor = *it;
6063       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6064
6065       int h, s, v;
6066       aQColor.getHsv( &h, &s, &v );
6067       if( abs( h - aHue ) < aTolerance )
6068       {
6069         ok = false;
6070         break;
6071       }
6072     }
6073
6074     if( ok )
6075       break;
6076   }
6077
6078   QColor aColor;
6079   aColor.setHsv( aHue, 255, 255 );
6080
6081   SALOMEDS::Color aSColor;
6082   aSColor.R = aColor.redF();
6083   aSColor.G = aColor.greenF();
6084   aSColor.B = aColor.blueF();
6085
6086   return aSColor;
6087 }
6088
6089 const char* gSeparator = "_"; // character used to separate parameter names
6090 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6091 const char* gPathSep   = "|"; // character used to separate paths
6092
6093 /*!
6094  * \brief Store visual parameters
6095  *
6096  * This method is called just before the study document is saved.
6097  * Store visual parameters in AttributeParameter attribute(s)
6098  */
6099 void SMESHGUI::storeVisualParameters (int savePoint)
6100 {
6101   // localizing
6102   Kernel_Utils::Localizer loc;
6103
6104   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6105   if (!appStudy || !appStudy->studyDS())
6106     return;
6107   _PTR(Study) studyDS = appStudy->studyDS();
6108
6109   // componentName is used for encoding of entries when storing them in IParameters
6110   std::string componentName = myComponentSMESH->ComponentDataType();
6111   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6112   //if (!aSComponent) return;
6113
6114   // IParameters
6115   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6116                                                              componentName.c_str(),
6117                                                              savePoint);
6118   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6119
6120   // store custom markers
6121   if( !myMarkerMap.empty() )
6122   {
6123     VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6124     for( ; anIter != myMarkerMap.end(); anIter++ )
6125     {
6126       int anId = anIter->first;
6127       VTK::MarkerData aMarkerData = anIter->second;
6128       std::string aMarkerFileName = aMarkerData.first;
6129       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6130       if( aMarkerTexture.size() < 3 )
6131         continue; // should contain at least width, height and the first value
6132
6133       QString aPropertyName( "texture" );
6134       aPropertyName += gSeparator;
6135       aPropertyName += QString::number( anId );
6136
6137       QString aPropertyValue = aMarkerFileName.c_str();
6138       aPropertyValue += gPathSep;
6139
6140       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6141       ushort aWidth = *aTextureIter++;
6142       ushort aHeight = *aTextureIter++;
6143       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6144       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6145       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6146         aPropertyValue += QString::number( *aTextureIter );
6147
6148       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6149     }
6150   }
6151
6152   // viewers counters are used for storing view_numbers in IParameters
6153   int vtkViewers = 0;
6154
6155   // main cycle to store parameters of displayed objects
6156   QList<SUIT_ViewManager*> lst;
6157   QList<SUIT_ViewManager*>::Iterator it;
6158   getApp()->viewManagers(lst);
6159   for (it = lst.begin(); it != lst.end(); it++)
6160   {
6161     SUIT_ViewManager* vman = *it;
6162     QString vType = vman->getType();
6163
6164     // saving VTK actors properties
6165     if (vType == SVTK_Viewer::Type())
6166     {
6167       // store the clipping planes attached to the view manager
6168       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6169       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6170       if( anIter != myClippingPlaneInfoMap.end() )
6171         aClippingPlaneInfoList = anIter->second;
6172
6173       if( !aClippingPlaneInfoList.empty() ) {
6174         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6175         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6176         {
6177           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6178           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6179
6180           QString aPropertyName( "ClippingPlane" );
6181           aPropertyName += gSeparator;
6182           aPropertyName += QString::number( vtkViewers );
6183           aPropertyName += gSeparator;
6184           aPropertyName += QString::number( anId );
6185
6186           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6187           aPropertyValue += gDigitsSep;
6188           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6189           aPropertyValue += gDigitsSep;
6190           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6191             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6192             aPropertyValue += gDigitsSep;
6193             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6194             aPropertyValue += gDigitsSep;
6195             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6196             aPropertyValue += gDigitsSep;
6197             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6198             aPropertyValue += gDigitsSep;
6199             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6200             aPropertyValue += gDigitsSep;
6201             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6202             aPropertyValue += gDigitsSep;
6203             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6204           }
6205           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6206             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6207             aPropertyValue += gDigitsSep;
6208             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6209             aPropertyValue += gDigitsSep;
6210             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6211             aPropertyValue += gDigitsSep;
6212             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6213           }
6214
6215           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6216         }
6217       }
6218
6219       QVector<SUIT_ViewWindow*> views = vman->getViews();
6220       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6221       {
6222         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6223         {
6224           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6225           vtkActorCollection* allActors = aCopy.GetActors();
6226           allActors->InitTraversal();
6227           while (vtkActor* actor = allActors->GetNextActor())
6228           {
6229             if (actor->GetVisibility()) // store only visible actors
6230             {
6231               SMESH_Actor* aSmeshActor = 0;
6232               if (actor->IsA("SMESH_Actor"))
6233                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6234               if (aSmeshActor && aSmeshActor->hasIO())
6235               {
6236                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6237                 if (io->hasEntry())
6238                 {
6239                   // entry is "encoded" = it does NOT contain component address,
6240                   // since it is a subject to change on next component loading
6241                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6242
6243                   std::string param, vtkParam = vType.toLatin1().data();
6244                   vtkParam += gSeparator;
6245                   vtkParam += QString::number(vtkViewers).toLatin1().data();
6246                   vtkParam += gSeparator;
6247
6248                   // Visibility
6249                   param = vtkParam + "Visibility";
6250                   ip->setParameter(entry, param, "On");
6251
6252                   // Representation
6253                   param = vtkParam + "Representation";
6254                   ip->setParameter(entry, param, QString::number
6255                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6256
6257                   // IsShrunk
6258                   param = vtkParam + "IsShrunk";
6259                   ip->setParameter(entry, param, QString::number
6260                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6261
6262                   // Displayed entities
6263                   unsigned int aMode = aSmeshActor->GetEntityMode();
6264                   bool isE  = aMode & SMESH_Actor::eEdges;
6265                   bool isF  = aMode & SMESH_Actor::eFaces;
6266                   bool isV  = aMode & SMESH_Actor::eVolumes;
6267                   bool is0d = aMode & SMESH_Actor::e0DElements;
6268                   bool isB  = aMode & SMESH_Actor::eBallElem;
6269
6270                   QString modeStr ("e");
6271                   modeStr += gDigitsSep; modeStr += QString::number(isE);
6272                   modeStr += gDigitsSep; modeStr += "f";
6273                   modeStr += gDigitsSep; modeStr += QString::number(isF);
6274                   modeStr += gDigitsSep; modeStr += "v";
6275                   modeStr += gDigitsSep; modeStr += QString::number(isV);
6276                   modeStr += gDigitsSep; modeStr += "0d";
6277                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
6278                   modeStr += gDigitsSep; modeStr += "b";
6279                   modeStr += gDigitsSep; modeStr += QString::number(isB);
6280
6281                   param = vtkParam + "Entities";
6282                   ip->setParameter(entry, param, modeStr.toLatin1().data());
6283
6284                   // Colors
6285                   double r, g, b;
6286                   int delta;
6287
6288                   aSmeshActor->GetSufaceColor(r, g, b, delta);
6289                   QStringList colorStr;
6290                   colorStr << "surface";
6291                   colorStr << QString::number(r);
6292                   colorStr << QString::number(g);
6293                   colorStr << QString::number(b);
6294
6295                   colorStr << "backsurface";
6296                   colorStr << QString::number(delta);
6297
6298                   aSmeshActor->GetVolumeColor(r, g, b, delta);
6299                   colorStr << "volume";
6300                   colorStr << QString::number(r);
6301                   colorStr << QString::number(g);
6302                   colorStr << QString::number(b);
6303                   colorStr << QString::number(delta);
6304
6305                   aSmeshActor->GetEdgeColor(r, g, b);
6306                   colorStr << "edge";
6307                   colorStr << QString::number(r);
6308                   colorStr << QString::number(g);
6309                   colorStr << QString::number(b);
6310
6311                   aSmeshActor->GetNodeColor(r, g, b);
6312                   colorStr << "node";
6313                   colorStr << QString::number(r);
6314                   colorStr << QString::number(g);
6315                   colorStr << QString::number(b);
6316
6317                   aSmeshActor->GetOutlineColor(r, g, b);
6318                   colorStr << "outline";
6319                   colorStr << QString::number(r);
6320                   colorStr << QString::number(g);
6321                   colorStr << QString::number(b);
6322
6323                   aSmeshActor->Get0DColor(r, g, b);
6324                   colorStr << "elem0d";
6325                   colorStr << QString::number(r);
6326                   colorStr << QString::number(g);
6327                   colorStr << QString::number(b);
6328
6329                   aSmeshActor->GetBallColor(r, g, b);
6330                   colorStr << "ball";
6331                   colorStr << QString::number(r);
6332                   colorStr << QString::number(g);
6333                   colorStr << QString::number(b);
6334
6335                   aSmeshActor->GetFacesOrientationColor(r, g, b);
6336                   colorStr << "orientation";
6337                   colorStr << QString::number(r);
6338                   colorStr << QString::number(g);
6339                   colorStr << QString::number(b);
6340
6341                   param = vtkParam + "Colors";
6342                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6343
6344                   // Sizes
6345                   QStringList sizeStr;
6346                   sizeStr << "line";
6347                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6348                   sizeStr << "outline";
6349                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6350                   sizeStr << "elem0d";
6351                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6352                   sizeStr << "ball";
6353                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6354                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6355                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6356                   sizeStr << "shrink";
6357                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6358                   sizeStr << "orientation";
6359                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6360                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6361
6362                   param = vtkParam + "Sizes";
6363                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6364
6365                   // Point marker
6366                   QString markerStr;
6367
6368                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6369                   if( aMarkerType == VTK::MT_USER ) {
6370                     markerStr += "custom";
6371                     markerStr += gDigitsSep;
6372                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6373                   }
6374                   else {
6375                     markerStr += "std";
6376                     markerStr += gDigitsSep;
6377                     markerStr += QString::number( (int)aMarkerType );
6378                     markerStr += gDigitsSep;
6379                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6380                   }
6381
6382                   param = vtkParam + "PointMarker";
6383                   ip->setParameter(entry, param, markerStr.toLatin1().data());
6384
6385                   // Opacity
6386                   param = vtkParam + "Opacity";
6387                   ip->setParameter(entry, param,
6388                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6389
6390                   // Clipping
6391                   param = vtkParam + "ClippingPlane";
6392                   int aPlaneId = 0;
6393                   if( !aClippingPlaneInfoList.empty() ) {
6394                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6395                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6396                     {
6397                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6398                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6399                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
6400                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6401                         if( aSmeshActor == *anIter2 ) {
6402                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6403                                             QString::number( anId ).toLatin1().constData() );
6404                           break;
6405                         }
6406                       }
6407                     }
6408                   }
6409                   if( aPlaneId == 0 )
6410                     ip->setParameter( entry, param, "Off" );
6411                 } // if (io->hasEntry())
6412               } // SMESH_Actor && hasIO
6413             } // isVisible
6414           } // while.. actors traversal
6415         } // if (vtkView)
6416       } // for (views)
6417       vtkViewers++;
6418     } // if (SVTK view model)
6419   } // for (viewManagers)
6420 }
6421
6422 // data structures for clipping planes processing
6423 typedef struct {
6424   int Id;
6425   int Mode;
6426   bool isOpenGLClipping;
6427   vtkIdType RelativeOrientation;
6428   double Distance;
6429   double Angle[2];
6430   int AbsoluteOrientation;
6431   double X, Y, Z, Dx, Dy, Dz;
6432 } TPlaneData;
6433 typedef std::list<TPlaneData>         TPlaneDataList;
6434 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6435
6436 typedef std::list<vtkActor*>          TActorList;
6437 typedef struct {
6438   int PlaneId;
6439   TActorList ActorList;
6440   SUIT_ViewManager* ViewManager;
6441 } TPlaneInfo;
6442 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6443 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6444
6445 /*!
6446  * \brief Restore visual parameters
6447  *
6448  * This method is called after the study document is opened.
6449  * Restore visual parameters from AttributeParameter attribute(s)
6450  */
6451 void SMESHGUI::restoreVisualParameters (int savePoint)
6452 {
6453   // localizing
6454   Kernel_Utils::Localizer loc;
6455
6456   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6457   if (!appStudy || !appStudy->studyDS())
6458     return;
6459   _PTR(Study) studyDS = appStudy->studyDS();
6460
6461   // componentName is used for encoding of entries when storing them in IParameters
6462   std::string componentName = myComponentSMESH->ComponentDataType();
6463
6464   // IParameters
6465   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6466                                                              componentName.c_str(),
6467                                                              savePoint);
6468   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6469
6470   // restore custom markers and map of clipping planes
6471   TPlaneDataMap aPlaneDataMap;
6472
6473   std::vector<std::string> properties = ip->getProperties();
6474   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6475   {
6476     std::string property = *propIt;
6477     QString aPropertyName( property.c_str() );
6478     QString aPropertyValue( ip->getProperty( property ).c_str() );
6479
6480     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6481     if( aPropertyNameList.isEmpty() )
6482       continue;
6483
6484     QString aPropertyType = aPropertyNameList[0];
6485     if( aPropertyType == "texture" )
6486     {
6487       if( aPropertyNameList.size() != 2 )
6488         continue;
6489
6490       bool ok = false;
6491       int anId = aPropertyNameList[1].toInt( &ok );
6492       if( !ok || anId < 1 )
6493         continue;
6494
6495       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6496       if( aPropertyValueList.size() != 2 )
6497         continue;
6498
6499       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6500       QString aMarkerTextureString = aPropertyValueList[1];
6501       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6502       if( aMarkerTextureStringList.size() != 3 )
6503         continue;
6504
6505       ok = false;
6506       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6507       if( !ok )
6508         continue;
6509
6510       ok = false;
6511       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6512       if( !ok )
6513         continue;
6514
6515       VTK::MarkerTexture aMarkerTexture;
6516       aMarkerTexture.push_back( aWidth );
6517       aMarkerTexture.push_back( aHeight );
6518
6519       QString aMarkerTextureData = aMarkerTextureStringList[2];
6520       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6521       {
6522         QChar aChar = aMarkerTextureData.at( i );
6523         if( aChar.isDigit() )
6524           aMarkerTexture.push_back( aChar.digitValue() );
6525       }
6526
6527       myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6528     }
6529     else if( aPropertyType == "ClippingPlane" )
6530     {
6531       if( aPropertyNameList.size() != 3 )
6532         continue;
6533
6534       bool ok = false;
6535       int aViewId = aPropertyNameList[1].toInt( &ok );
6536       if( !ok || aViewId < 0 )
6537         continue;
6538
6539       ok = false;
6540       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6541       if( !ok || aClippingPlaneId < 0 )
6542         continue;
6543
6544       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6545       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6546         continue;
6547
6548       TPlaneData aPlaneData;
6549       aPlaneData.AbsoluteOrientation = false;
6550       aPlaneData.RelativeOrientation = 0;
6551       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6552       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6553       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6554
6555       aPlaneData.Id = aClippingPlaneId;
6556
6557       ok = false;
6558       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6559       if( !ok )
6560         continue;
6561
6562       ok = false;
6563       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6564       if( !ok )
6565         continue;
6566
6567       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6568       {
6569         ok = false;
6570         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6571         if( !ok )
6572           continue;
6573
6574         ok = false;
6575         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6576         if( !ok )
6577           continue;
6578
6579         ok = false;
6580         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6581         if( !ok )
6582           continue;
6583
6584         ok = false;
6585         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6586         if( !ok )
6587           continue;
6588
6589         ok = false;
6590         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6591         if( !ok )
6592           continue;
6593
6594         ok = false;
6595         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6596         if( !ok )
6597           continue;
6598
6599         ok = false;
6600         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6601         if( !ok )
6602           continue;
6603       }
6604       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6605         ok = false;
6606         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6607         if( !ok )
6608           continue;
6609
6610         ok = false;
6611         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6612         if( !ok )
6613           continue;
6614
6615         ok = false;
6616         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6617         if( !ok )
6618           continue;
6619
6620         ok = false;
6621         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6622         if( !ok )
6623           continue;
6624       }
6625
6626       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6627       aPlaneDataList.push_back( aPlaneData );
6628     }
6629   }
6630
6631   TPlaneInfoMap aPlaneInfoMap;
6632
6633   std::vector<std::string> entries = ip->getEntries();
6634
6635   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6636   {
6637     // entry is a normal entry - it should be "decoded" (setting base address of component)
6638     QString entry (ip->decodeEntry(*entIt).c_str());
6639
6640     // Check that the entry corresponds to a real object in the Study
6641     // as the object may be deleted or modified after the visual state is saved.
6642     _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6643     if (!so) continue; //Skip the not existent entry
6644
6645     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6646     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6647
6648     std::vector<std::string>::iterator namesIt = paramNames.begin();
6649     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6650
6651     // actors are stored in a map after displaying of them for
6652     // quicker access in the future: map < viewID to actor >
6653     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6654
6655     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6656     {
6657       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6658       // '_' is used as separator and should not be used in viewer type or parameter names.
6659       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6660       if (lst.size() != 3)
6661         continue;
6662
6663       QString viewerTypStr = lst[0];
6664       QString viewIndexStr = lst[1];
6665       QString paramNameStr = lst[2];
6666
6667       bool ok;
6668       int viewIndex = viewIndexStr.toUInt(&ok);
6669       if (!ok) // bad conversion of view index to integer
6670         continue;
6671
6672       // viewers
6673       if (viewerTypStr == SVTK_Viewer::Type())
6674       {
6675         SMESH_Actor* aSmeshActor = 0;
6676         if (vtkActors.IsBound(viewIndex))
6677           aSmeshActor = vtkActors.Find(viewIndex);
6678
6679         QList<SUIT_ViewManager*> lst;
6680         getApp()->viewManagers(viewerTypStr, lst);
6681
6682         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6683         SUIT_ViewManager* vman = NULL;
6684         if (viewIndex >= 0 && viewIndex < lst.count())
6685           vman = lst.at(viewIndex);
6686
6687         if (paramNameStr == "Visibility")
6688         {
6689           if (!aSmeshActor && displayer() && vman)
6690           {
6691             SUIT_ViewModel* vmodel = vman->getViewModel();
6692             // SVTK view model can be casted to SALOME_View
6693             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6694
6695             // store displayed actor in a temporary map for quicker
6696             // access later when restoring other parameters
6697             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6698             vtkRenderer* Renderer = vtkView->getRenderer();
6699             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6700             vtkActorCollection* theActors = aCopy.GetActors();
6701             theActors->InitTraversal();
6702             bool isFound = false;
6703             vtkActor *ac = theActors->GetNextActor();
6704             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6705               if (ac->IsA("SMESH_Actor")) {
6706                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6707                 if (aGeomAc->hasIO()) {
6708                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6709                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6710                     isFound = true;
6711                     vtkActors.Bind(viewIndex, aGeomAc);
6712                   }
6713                 }
6714               }
6715             }
6716           }
6717         } // if (paramNameStr == "Visibility")
6718         else
6719         {
6720           // the rest properties "work" with SMESH_Actor
6721           if (aSmeshActor)
6722           {
6723             QString val ((*valuesIt).c_str());
6724
6725             // Representation
6726             if (paramNameStr == "Representation") {
6727               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6728             }
6729             // IsShrunk
6730             else if (paramNameStr == "IsShrunk") {
6731               if (val.toInt()) {
6732                 if (!aSmeshActor->IsShrunk())
6733                   aSmeshActor->SetShrink();
6734               }
6735               else {
6736                 if (aSmeshActor->IsShrunk())
6737                   aSmeshActor->UnShrink();
6738               }
6739             }
6740             // Displayed entities
6741             else if (paramNameStr == "Entities") {
6742               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6743               int aEntityMode = SMESH_Actor::eAllEntity;
6744               for ( int i = 0; i < mode.count(); i+=2 ) {
6745                 if ( i < mode.count()-1 ) {
6746                   QString type = mode[i];
6747                   bool val = mode[i+1].toInt();
6748                   if      ( type == "e" && !val )
6749                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6750                   else if ( type == "f" && !val )
6751                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6752                   else if ( type == "v" && !val )
6753                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6754                   else if ( type == "0d" && !val )
6755                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6756                   else if ( type == "b" && !val )
6757                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6758                 }
6759               }
6760               aSmeshActor->SetEntityMode( aEntityMode );
6761             }
6762             // Colors
6763             else if (paramNameStr == "Colors") {
6764               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6765               QColor nodeColor;
6766               QColor edgeColor;
6767               QColor faceColor;
6768               QColor volumeColor;
6769               QColor elem0dColor;
6770               QColor ballColor;
6771               QColor outlineColor;
6772               QColor orientationColor;
6773               int deltaF;
6774               int deltaV;
6775               QColor c;
6776               double r, g, b;
6777               bool bOk;
6778               // below lines are required to get default values for delta coefficients
6779               // of backface color for faces and color of reversed volumes
6780               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6781               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6782               for ( int i = 0; i < colors.count(); i++ ) {
6783                 QString type = colors[i];
6784                 if ( type == "surface" ) {
6785                   // face color is set by 3 values r:g:b, where
6786                   // - r,g,b - is rgb color components
6787                   if ( i+1 >= colors.count() ) break;                  // format error
6788                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6789                   if ( i+2 >= colors.count() ) break;                  // format error
6790                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6791                   if ( i+3 >= colors.count() ) break;                  // format error
6792                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6793                   faceColor.setRgbF( r, g, b );
6794                   i += 3;
6795                 }
6796                 else if ( type == "backsurface" ) {
6797                   // backface color can be defined in several ways
6798                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6799                   // - in latest versions, it is set as delta coefficient
6800                   bool rgbOk = false, deltaOk;
6801                   if ( i+1 >= colors.count() ) break;                  // format error
6802                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6803                   int delta = colors[i+1].toInt( &deltaOk );
6804                   i++;                                 // shift index
6805                   if ( i+1 < colors.count() )          // index is shifted to 1
6806                     g = colors[i+1].toDouble( &rgbOk );
6807                   if ( rgbOk ) i++;                    // shift index
6808                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6809                     b = colors[i+1].toDouble( &rgbOk );
6810                   if ( rgbOk ) i++;
6811                   // - as currently there's no way to set directly backsurface color as it was before,
6812                   // we ignore old dump where r,g,b triple was set
6813                   // - also we check that delta parameter is set properly
6814                   if ( !rgbOk && deltaOk )
6815                     deltaF = delta;
6816                 }
6817                 else if ( type == "volume" ) {
6818                   // volume color is set by 4 values r:g:b:delta, where
6819                   // - r,g,b - is a normal volume rgb color components
6820                   // - delta - is a reversed volume color delta coefficient
6821                   if ( i+1 >= colors.count() ) break;                  // format error
6822                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6823                   if ( i+2 >= colors.count() ) break;                  // format error
6824                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6825                   if ( i+3 >= colors.count() ) break;                  // format error
6826                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6827                   if ( i+4 >= colors.count() ) break;                  // format error
6828                   int delta = colors[i+4].toInt( &bOk );
6829                   if ( !bOk ) break;                                   // format error
6830                   volumeColor.setRgbF( r, g, b );
6831                   deltaV = delta;
6832                   i += 4;
6833                 }
6834                 else if ( type == "edge" ) {
6835                   // edge color is set by 3 values r:g:b, where
6836                   // - r,g,b - is rgb color components
6837                   if ( i+1 >= colors.count() ) break;                  // format error
6838                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6839                   if ( i+2 >= colors.count() ) break;                  // format error
6840                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6841                   if ( i+3 >= colors.count() ) break;                  // format error
6842                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6843                   edgeColor.setRgbF( r, g, b );
6844                   i += 3;
6845                 }
6846                 else if ( type == "node" ) {
6847                   // node color is set by 3 values r:g:b, where
6848                   // - r,g,b - is rgb color components
6849                   if ( i+1 >= colors.count() ) break;                  // format error
6850                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6851                   if ( i+2 >= colors.count() ) break;                  // format error
6852                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6853                   if ( i+3 >= colors.count() ) break;                  // format error
6854                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6855                   nodeColor.setRgbF( r, g, b );
6856                   i += 3;
6857                 }
6858                 else if ( type == "elem0d" ) {
6859                   // 0d element color is set by 3 values r:g:b, where
6860                   // - r,g,b - is rgb color components
6861                   if ( i+1 >= colors.count() ) break;                  // format error
6862                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6863                   if ( i+2 >= colors.count() ) break;                  // format error
6864                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6865                   if ( i+3 >= colors.count() ) break;                  // format error
6866                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6867                   elem0dColor.setRgbF( r, g, b );
6868                   i += 3;
6869                 }
6870                 else if ( type == "ball" ) {
6871                   // ball color is set by 3 values r:g:b, where
6872                   // - r,g,b - is rgb color components
6873                   if ( i+1 >= colors.count() ) break;                  // format error
6874                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6875                   if ( i+2 >= colors.count() ) break;                  // format error
6876                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6877                   if ( i+3 >= colors.count() ) break;                  // format error
6878                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6879                   ballColor.setRgbF( r, g, b );
6880                   i += 3;
6881                 }
6882                 else if ( type == "outline" ) {
6883                   // outline color is set by 3 values r:g:b, where
6884                   // - r,g,b - is rgb color components
6885                   if ( i+1 >= colors.count() ) break;                  // format error
6886                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6887                   if ( i+2 >= colors.count() ) break;                  // format error
6888                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6889                   if ( i+3 >= colors.count() ) break;                  // format error
6890                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6891                   outlineColor.setRgbF( r, g, b );
6892                   i += 3;
6893                 }
6894                 else if ( type == "orientation" ) {
6895                   // orientation color is set by 3 values r:g:b, where
6896                   // - r,g,b - is rgb color components
6897                   if ( i+1 >= colors.count() ) break;                  // format error
6898                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6899                   if ( i+2 >= colors.count() ) break;                  // format error
6900                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6901                   if ( i+3 >= colors.count() ) break;                  // format error
6902                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6903                   orientationColor.setRgbF( r, g, b );
6904                   i += 3;
6905                 }
6906               }
6907               // node color
6908               if ( nodeColor.isValid() )
6909                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6910               // edge color
6911               if ( edgeColor.isValid() )
6912                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6913               // face color
6914               if ( faceColor.isValid() )
6915                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6916               // volume color
6917               if ( volumeColor.isValid() )
6918                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6919               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6920                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6921               // 0d element color
6922               if ( elem0dColor.isValid() )
6923                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6924               // ball color
6925               if ( ballColor.isValid() )
6926                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6927               // outline color
6928               if ( outlineColor.isValid() )
6929                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6930               // orientation color
6931               if ( orientationColor.isValid() )
6932                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6933             }
6934             // Sizes
6935             else if (paramNameStr == "Sizes") {
6936               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6937               bool bOk;
6938               int lineWidth = -1;
6939               int outlineWidth = -1;
6940               int elem0dSize = -1;
6941               //int ballSize = -1;
6942               double ballDiameter = -1.0;
6943               double ballScale = -1.0;
6944               double shrinkSize = -1;
6945               double orientationSize = -1;
6946               bool orientation3d = false;
6947               for ( int i = 0; i < sizes.count(); i++ ) {
6948                 QString type = sizes[i];
6949                 if ( type == "line" ) {
6950                   // line (wireframe) width is given as single integer value
6951                   if ( i+1 >= sizes.count() ) break;                    // format error
6952                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6953                   lineWidth = v;
6954                   i++;
6955                 }
6956                 if ( type == "outline" ) {
6957                   // outline width is given as single integer value
6958                   if ( i+1 >= sizes.count() ) break;                    // format error
6959                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6960                   outlineWidth = v;
6961                   i++;
6962                 }
6963                 else if ( type == "elem0d" ) {
6964                   // 0d element size is given as single integer value
6965                   if ( i+1 >= sizes.count() ) break;                    // format error
6966                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6967                   elem0dSize = v;
6968                   i++;
6969                 }
6970                 else if ( type == "ball" ) {
6971                   // balls are specified by two values: size:scale, where
6972                   // - size - is a integer value specifying size
6973                   // - scale - is a double value specifying scale factor
6974                   if ( i+1 >= sizes.count() ) break;                       // format error
6975                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6976                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6977                   if ( i+2 >= sizes.count() ) break;                       // format error
6978                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6979                   //ballSize = v1;
6980                   ballDiameter = v1;
6981                   ballScale = v2;
6982                   i += 2;
6983                 }
6984                 else if ( type == "shrink" ) {
6985                   // shrink factor is given as single floating point value
6986                   if ( i+1 >= sizes.count() ) break;                          // format error
6987                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6988                   shrinkSize = v;
6989                   i++;
6990                 }
6991                 else if ( type == "orientation" ) {
6992                   // orientation vectors are specified by two values size:3d, where
6993                   // - size - is a floating point value specifying scale factor
6994                   // - 3d - is a boolean
6995                   if ( i+1 >= sizes.count() ) break;                          // format error
6996                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6997                   if ( i+2 >= sizes.count() ) break;                          // format error
6998                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6999                   orientationSize = v1;
7000                   orientation3d = (bool)v2;
7001                   i += 2;
7002                 }
7003               }
7004               // line (wireframe) width
7005               if ( lineWidth > 0 )
7006                 aSmeshActor->SetLineWidth( lineWidth );
7007               // outline width
7008               if ( outlineWidth > 0 )
7009                 aSmeshActor->SetOutlineWidth( outlineWidth );
7010               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7011                 aSmeshActor->SetOutlineWidth( lineWidth );
7012               // 0d element size
7013               if ( elem0dSize > 0 )
7014                 aSmeshActor->Set0DSize( elem0dSize );
7015               // ball size
7016               /*if ( ballSize > 0 )
7017                 aSmeshActor->SetBallSize( ballSize );*/
7018               // ball diameter
7019               if ( ballDiameter > 0 )
7020                 aSmeshActor->SetBallSize( ballDiameter );
7021               // ball scale
7022               if ( ballScale > 0.0 )
7023                 aSmeshActor->SetBallScale( ballScale );
7024               // shrink factor
7025               if ( shrinkSize > 0 )
7026                 aSmeshActor->SetShrinkFactor( shrinkSize );
7027               // orientation vectors
7028               if ( orientationSize > 0 ) {
7029                 aSmeshActor->SetFacesOrientationScale( orientationSize );
7030                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7031               }
7032             }
7033             // Point marker
7034             else if (paramNameStr == "PointMarker") {
7035               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7036               if( data.count() >= 2 ) {
7037                 bool ok = false;
7038                 int aParam1 = data[1].toInt( &ok );
7039                 if( ok ) {
7040                   if( data[0] == "std" && data.count() == 3 ) {
7041                     int aParam2 = data[2].toInt( &ok );
7042                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7043                   }
7044                   else if( data[0] == "custom" ) {
7045                     VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7046                     if( markerIt != myMarkerMap.end() ) {
7047                       VTK::MarkerData aMarkerData = markerIt->second;
7048                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7049                     }
7050                   }
7051                 }
7052               }
7053             }
7054             // Opacity
7055             else if (paramNameStr == "Opacity") {
7056               aSmeshActor->SetOpacity(val.toFloat());
7057             }
7058             // Clipping
7059             else if (paramNameStr.startsWith("ClippingPlane")) {
7060               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7061               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7062               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7063               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7064               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7065               // new format - val looks like "Off" or "0" (plane id)
7066               // (note: in new format "Off" value is used only for consistency,
7067               //  so it is processed together with values in old format)
7068               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7069               if( anIsOldFormat ) {
7070                 if (paramNameStr == "ClippingPlane1" || val == "Off")
7071                   aSmeshActor->RemoveAllClippingPlanes();
7072                 if (val != "Off") {
7073                   QList<SUIT_ViewManager*> lst;
7074                   getApp()->viewManagers(viewerTypStr, lst);
7075                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7076                   if (viewIndex >= 0 && viewIndex < lst.count()) {
7077                     SUIT_ViewManager* vman = lst.at(viewIndex);
7078                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7079
7080                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7081
7082                     SMESH::TActorList anActorList;
7083                     anActorList.push_back( aSmeshActor );
7084                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7085                     aPlane->myViewWindow = vtkView;
7086                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7087                     aPlane->PlaneMode = aMode;
7088                     bool isOpenGLClipping = ( bool )vals[1].toInt();
7089                     aPlane->IsOpenGLClipping = isOpenGLClipping;
7090                     if ( aMode == SMESH::Absolute ) {
7091                       aPlane->myAbsoluteOrientation = vals[2].toInt();
7092                       aPlane->X = vals[3].toFloat();
7093                       aPlane->Y = vals[4].toFloat();
7094                       aPlane->Z = vals[5].toFloat();
7095                       aPlane->Dx = vals[6].toFloat();
7096                       aPlane->Dy = vals[7].toFloat();
7097                       aPlane->Dz = vals[8].toFloat();
7098                     }
7099                     else if ( aMode == SMESH::Relative ) {
7100                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7101                       aPlane->myDistance = vals[3].toFloat();
7102                       aPlane->myAngle[0] = vals[4].toFloat();
7103                       aPlane->myAngle[1] = vals[5].toFloat();
7104                     }
7105
7106                     if( aPlane ) {
7107                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7108                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7109                         aClippingPlaneInfo.Plane = aPlane;
7110                         aClippingPlaneInfo.ActorList = anActorList;
7111                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7112                       }
7113                     }
7114                   }
7115                 }
7116               }
7117               else {
7118                 bool ok = false;
7119                 int aPlaneId = val.toInt( &ok );
7120                 if( ok && aPlaneId >= 0 ) {
7121                   bool anIsDefinedPlane = false;
7122                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7123                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7124                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7125                     TPlaneInfo& aPlaneInfo = *anIter;
7126                     if( aPlaneInfo.PlaneId == aPlaneId ) {
7127                       aPlaneInfo.ActorList.push_back( aSmeshActor );
7128                       anIsDefinedPlane = true;
7129                       break;
7130                     }
7131                   }
7132                   if( !anIsDefinedPlane ) {
7133                     TPlaneInfo aPlaneInfo;
7134                     aPlaneInfo.PlaneId = aPlaneId;
7135                     aPlaneInfo.ActorList.push_back( aSmeshActor );
7136                     aPlaneInfo.ViewManager = vman;
7137
7138                     // to make the list sorted by plane id
7139                     anIter = aPlaneInfoList.begin();
7140                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7141                       const TPlaneInfo& aPlaneInfoRef = *anIter;
7142                       if( aPlaneInfoRef.PlaneId > aPlaneId )
7143                         break;
7144                     }
7145                     aPlaneInfoList.insert( anIter, aPlaneInfo );
7146                   }
7147                 }
7148               }
7149             }
7150           } // if (aSmeshActor)
7151         } // other parameters than Visibility
7152       }
7153     } // for names/parameters iterator
7154   } // for entries iterator
7155
7156   // take into account planes with empty list of actors referred to them
7157   QList<SUIT_ViewManager*> aVMList;
7158   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7159
7160   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7161   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7162     int aViewId = aPlaneDataIter->first;
7163     if( aViewId >= 0 && aViewId < aVMList.count() ) {
7164       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7165
7166       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7167
7168       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7169       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7170       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7171         const TPlaneData& aPlaneData = *anIter2;
7172         int aPlaneId = aPlaneData.Id;
7173
7174         bool anIsFound = false;
7175         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7176         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7177           const TPlaneInfo& aPlaneInfo = *anIter3;
7178           if( aPlaneInfo.PlaneId == aPlaneId ) {
7179             anIsFound = true;
7180             break;
7181           }
7182         }
7183
7184         if( !anIsFound ) {
7185           TPlaneInfo aPlaneInfo; // ActorList field is empty
7186           aPlaneInfo.PlaneId = aPlaneId;
7187           aPlaneInfo.ViewManager = aViewManager;
7188
7189           // to make the list sorted by plane id
7190           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7191           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7192             const TPlaneInfo& aPlaneInfoRef = *anIter4;
7193             if( aPlaneInfoRef.PlaneId > aPlaneId )
7194               break;
7195           }
7196           aPlaneInfoList.insert( anIter4, aPlaneInfo );
7197         }
7198       }
7199     }
7200   }
7201
7202   // add clipping planes to actors according to the restored parameters
7203   // and update the clipping plane map
7204   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7205   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7206     int aViewId = anIter1->first;
7207     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7208
7209     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7210     if( anIter2 == aPlaneDataMap.end() )
7211       continue;
7212     const TPlaneDataList& aPlaneDataList = anIter2->second;
7213
7214     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7215     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7216       const TPlaneInfo& aPlaneInfo = *anIter3;
7217       int aPlaneId = aPlaneInfo.PlaneId;
7218       const TActorList& anActorList = aPlaneInfo.ActorList;
7219       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7220       if( !aViewManager )
7221         continue;
7222
7223       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7224       if( !aViewWindow )
7225         continue;
7226
7227       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7228
7229       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7230       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7231         const TPlaneData& aPlaneData = *anIter4;
7232         if( aPlaneData.Id == aPlaneId ) {
7233           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7234           aPlane->myViewWindow = aViewWindow;
7235           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7236           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7237           if ( aPlane->PlaneMode == SMESH::Absolute ) {
7238             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7239             aPlane->X = aPlaneData.X;
7240             aPlane->Y = aPlaneData.Y;
7241             aPlane->Z = aPlaneData.Z;
7242             aPlane->Dx = aPlaneData.Dx;
7243             aPlane->Dy = aPlaneData.Dy;
7244             aPlane->Dz = aPlaneData.Dz;
7245           }
7246           else if ( aPlane->PlaneMode == SMESH::Relative ) {
7247             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7248             aPlane->myDistance = aPlaneData.Distance;
7249             aPlane->myAngle[0] = aPlaneData.Angle[0];
7250             aPlane->myAngle[1] = aPlaneData.Angle[1];
7251           }
7252           if( aPlane ) {
7253             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7254               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7255               aClippingPlaneInfo.Plane = aPlane;
7256               aClippingPlaneInfo.ActorList = anActorList;
7257               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7258             }
7259           }
7260           break;
7261         }
7262       }
7263
7264     }
7265   }
7266
7267
7268   // update all VTK views
7269   QList<SUIT_ViewManager*> lst;
7270   getApp()->viewManagers(lst);
7271   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7272     SUIT_ViewModel* vmodel = (*it)->getViewModel();
7273     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7274       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7275       // set OpenGL clipping planes
7276       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7277       vtkActorCollection* anAllActors = aCopy.GetActors();
7278       anAllActors->InitTraversal();
7279       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7280         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7281           anActor->SetOpenGLClippingPlane();
7282
7283       vtkView->getRenderer()->ResetCameraClippingRange();
7284       vtkView->Repaint();
7285     }
7286   }
7287 }
7288
7289 /*!
7290   \brief Adds preferences for dfont of VTK viewer
7291   \param label label
7292   \param pIf group identifier
7293   \param param parameter
7294   \return identifier of preferences
7295 */
7296 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7297 {
7298   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7299
7300   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7301
7302   QStringList fam;
7303   fam.append( tr( "SMESH_FONT_ARIAL" ) );
7304   fam.append( tr( "SMESH_FONT_COURIER" ) );
7305   fam.append( tr( "SMESH_FONT_TIMES" ) );
7306
7307   setPreferenceProperty( tfont, "fonts", fam );
7308
7309   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7310   if ( needSize ) f = f | QtxFontEdit::Size;
7311   setPreferenceProperty( tfont, "features", f );
7312
7313   return tfont;
7314 }
7315
7316 /*!
7317   \brief Actions after hypothesis edition
7318   Updates object browser after hypothesis edition
7319 */
7320 void SMESHGUI::onHypothesisEdit( int result )
7321 {
7322   if( result == 1 )
7323     SMESHGUI::Modified();
7324   updateObjBrowser( true );
7325 }
7326
7327 /*!
7328   \brief Actions after choosing menu of control modes
7329   Updates control mode actions according to current selection
7330 */
7331 void SMESHGUI::onUpdateControlActions()
7332 {
7333   SALOME_ListIO selected;
7334   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7335     aSel->selectedObjects( selected );
7336
7337   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7338   if ( selected.Extent() ) {
7339     if ( selected.First()->hasEntry() ) {
7340       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7341         aControl = anActor->GetControlMode();
7342         SALOME_ListIteratorOfListIO it(selected);
7343         for ( it.Next(); it.More(); it.Next() ) {
7344           Handle(SALOME_InteractiveObject) anIO = it.Value();
7345           if ( anIO->hasEntry() ) {
7346             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7347               if ( aControl != anActor->GetControlMode() ) {
7348                 aControl = SMESH_Actor::eNone;
7349                 break;
7350               }
7351             }
7352           }
7353         }
7354       }
7355     }
7356   }
7357
7358   int anAction = ActionToControl( aControl, true );
7359   if ( anAction)
7360     action( anAction )->setChecked( true );
7361   else {
7362     QMenu* send = (QMenu*)sender();
7363     QList<QAction*> actions = send->actions();
7364     for ( int i = 0; i < actions.size(); i++ )
7365       actions[i]->setChecked( false );
7366   }
7367 }
7368
7369
7370 /*!
7371   \brief Signal handler closing(SUIT_ViewWindow*) of a view
7372   \param pview view being closed
7373 */
7374 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7375 #ifndef DISABLE_PLOT2DVIEWER
7376   //Crear all Plot2d Viewers if need.
7377   SMESH::ClearPlot2Viewers(pview);
7378 #endif
7379   EmitSignalCloseView();
7380 }
7381
7382 void SMESHGUI::message( const QString& msg )
7383 {
7384   // dispatch message
7385   QStringList data = msg.split("/");
7386   if ( data.count() > 0 ) {
7387     if ( data.first() == "mesh_loading" ) {
7388       // get mesh entry
7389       QString entry = data.count() > 1 ? data[1] : QString();
7390       if ( entry.isEmpty() )
7391         return;
7392       // get study
7393       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7394       // get mesh name
7395       _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7396       QString name;
7397       if ( obj )
7398         name = SMESH::fromUtf8(obj->GetName());
7399       if ( name.isEmpty() )
7400         return;
7401
7402       if ( data.last() == "stop" )
7403         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7404       else
7405         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7406       QApplication::processEvents();
7407     }
7408   }
7409 }
7410
7411 /*!
7412   \brief Connects or disconnects signals about activating and cloning view on the module slots
7413   \param pview view which is connected/disconnected
7414 */
7415 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7416   if(!pview)
7417     return;
7418
7419   SUIT_ViewManager* viewMgr = pview->getViewManager();
7420   if ( viewMgr ) {
7421     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7422                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7423
7424     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7425              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7426   }
7427 }
7428
7429 /*!
7430   \brief Return \c true if object can be renamed
7431 */
7432 bool SMESHGUI::renameAllowed( const QString& entry) const {
7433   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7434   if( !anApp )
7435     return false;
7436
7437   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7438   if( !appStudy )
7439     return false;
7440
7441   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7442
7443   if(!obj)
7444     return false;
7445
7446   if(appStudy->isComponent(entry) || obj->isReference())
7447     return false;
7448
7449   // check type to prevent renaming of inappropriate objects
7450   int aType = SMESHGUI_Selection::type(qPrintable(entry));
7451   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7452       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7453       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7454       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7455       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7456     return true;
7457
7458   return false;
7459 }
7460
7461 /*!
7462   Rename object by entry.
7463   \param entry entry of the object
7464   \param name new name of the object
7465   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7466 */
7467 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7468
7469   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7470   if( !anApp )
7471     return false;
7472
7473   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7474
7475   if(!appStudy)
7476     return false;
7477
7478   _PTR(Study) aStudy = appStudy->studyDS();
7479
7480   if(!aStudy)
7481     return false;
7482
7483   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7484   if ( aLocked ) {
7485     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7486     return false;
7487   }
7488
7489
7490   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7491   _PTR(GenericAttribute) anAttr;
7492   _PTR(AttributeName) aName;
7493   if ( obj ) {
7494     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7495       aName = anAttr;
7496       // check type to prevent renaming of inappropriate objects
7497       int aType = SMESHGUI_Selection::type( qPrintable(entry));
7498       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7499           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7500           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7501           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7502           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7503         if ( !name.isEmpty() ) {
7504           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7505
7506           // update name of group object and its actor
7507           Handle(SALOME_InteractiveObject) IObject =
7508             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7509
7510           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7511           if( !aGroupObject->_is_nil() ) {
7512             aGroupObject->SetName( qUtf8Printable(name) );
7513             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7514               anActor->setName( qUtf8Printable(name) );
7515           }
7516           return true;
7517         }
7518       }
7519     }
7520   }
7521   return false;
7522 }
7523
7524 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7525 {
7526   static QList<QColor> colors;
7527
7528   if ( colors.isEmpty() ) {
7529
7530     for (int s = 0; s < 2 ; s++)
7531     {
7532       for (int v = 100; v >= 40; v = v - 20)
7533       {
7534         for (int h = 0; h < 359 ; h = h + 60)
7535         {
7536           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7537         }
7538       }
7539     }
7540   }
7541   static int currentColor = randomize( colors.size() );
7542
7543   SALOMEDS::Color color;
7544   color.R = (double)colors[currentColor].red()   / 255.0;
7545   color.G = (double)colors[currentColor].green() / 255.0;
7546   color.B = (double)colors[currentColor].blue()  / 255.0;
7547
7548   currentColor = (currentColor+1) % colors.count();
7549
7550   return color;
7551 }