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_Add0DElemsOnAllNodesDlg.h"
  34 #include "SMESHGUI_AddMeshElementDlg.h"
  35 #include "SMESHGUI_AddQuadraticElementDlg.h"
  36 #include "SMESHGUI_BuildCompoundDlg.h"
  37 #include "SMESHGUI_ClippingDlg.h"
  38 #include "SMESHGUI_ComputeDlg.h"
  39 #include "SMESHGUI_ConvToQuadOp.h"
  40 #include "SMESHGUI_CopyMeshDlg.h"
  41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
  42 #include "SMESHGUI_DeleteGroupDlg.h"
  43 #include "SMESHGUI_DisplayEntitiesDlg.h"
  44 #include "SMESHGUI_Displayer.h"
  45 #include "SMESHGUI_DuplicateNodesDlg.h"
  46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
  47 #include "SMESHGUI_ExtrusionDlg.h"
  48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
  49 #include "SMESHGUI_FieldSelectorWdg.h"
  50 #include "SMESHGUI_FileInfoDlg.h"
  51 #include "SMESHGUI_FileValidator.h"
  52 #include "SMESHGUI_FilterDlg.h"
  53 #include "SMESHGUI_FilterLibraryDlg.h"
  54 #include "SMESHGUI_FilterUtils.h"
  55 #include "SMESHGUI_FindElemByPointDlg.h"
  56 #include "SMESHGUI_GEOMGenUtils.h"
  57 #include "SMESHGUI_GroupDlg.h"
  58 #include "SMESHGUI_GroupOnShapeDlg.h"
  59 #include "SMESHGUI_GroupOpDlg.h"
  60 #include "SMESHGUI_GroupUtils.h"
  61 #include "SMESHGUI_Hypotheses.h"
  62 #include "SMESHGUI_HypothesesUtils.h"
  63 #include "SMESHGUI_Make2DFrom3DOp.h"
  64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
  65 #include "SMESHGUI_Measurements.h"
  66 #include "SMESHGUI_MergeDlg.h"
  67 #include "SMESHGUI_MeshInfo.h"
  68 #include "SMESHGUI_MeshOp.h"
  69 #include "SMESHGUI_MeshOrderOp.h"
  70 #include "SMESHGUI_MeshPatternDlg.h"
  71 #include "SMESHGUI_MeshUtils.h"
  72 #include "SMESHGUI_MultiEditDlg.h"
  73 #include "SMESHGUI_NodesDlg.h"
  74 #include "SMESHGUI_OffsetDlg.h"
  75 #include "SMESHGUI_Operations.h"
  76 #include "SMESHGUI_PatternUtils.h"
  77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
  78 #include "SMESHGUI_PropertiesDlg.h"
  79 #include "SMESHGUI_RemoveElementsDlg.h"
  80 #include "SMESHGUI_RemoveNodesDlg.h"
  81 #include "SMESHGUI_RenumberingDlg.h"
  82 #include "SMESHGUI_ReorientFacesDlg.h"
  83 #include "SMESHGUI_RevolutionDlg.h"
  84 #include "SMESHGUI_RotationDlg.h"
  85 #include "SMESHGUI_ScaleDlg.h"
  86 #include "SMESHGUI_Selection.h"
  87 #include "SMESHGUI_SewingDlg.h"
  88 #include "SMESHGUI_SingleEditDlg.h"
  89 #include "SMESHGUI_SmoothingDlg.h"
  90 #include "SMESHGUI_SpinBox.h"
  91 #include "SMESHGUI_SplitBiQuad.h"
  92 #include "SMESHGUI_SymmetryDlg.h"
  93 #include "SMESHGUI_TranslationDlg.h"
  94 #include "SMESHGUI_TransparencyDlg.h"
  95 #include "SMESHGUI_Utils.h"
  96 #include "SMESHGUI_VTKUtils.h"
  97
  98 #include "SMESH_version.h"
  99
 100 #include "SMESH_Actor.h"
 101 #include "SMESH_ActorUtils.h"
 102 #include "SMESH_Client.hxx"
 103 #include "SMESH_Comment.hxx"
 104 #include "SMESH_ControlsDef.hxx"
 105 #include "SMESH_ScalarBarActor.h"
 106 #include "SMESH_TypeFilter.hxx"
 107 #include "SMESH_Component_Generator.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() : SalomeApp_Module( "SMESH" )
2160 {
2161   if ( CORBA::is_nil( myComponentSMESH ) )
2162   {
2163     CORBA::Boolean anIsEmbeddedMode;
2164     SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
2165     if( dynamic_cast<SALOME_NamingService *>(ns) )
2166       myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2167     else
2168       {
2169         Engines::EngineComponent_var comp = RetrieveSMESHInstance();
2170         myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
2171       }
2172
2173     //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2174
2175     //  0019923: EDF 765 SMESH : default values of hypothesis
2176     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2177     int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2178     myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2179     nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2180     myComponentSMESH->SetDefaultNbSegments( nbSeg );
2181
2182     const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2183     for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2184       if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2185       {
2186         QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2187         myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2188       }
2189   }
2190
2191   myActiveDialogBox = 0;
2192   myFilterLibraryDlg = 0;
2193   myState = -1;
2194   myDisplayer = 0;
2195
2196   myEventCallbackCommand = vtkCallbackCommand::New();
2197   myEventCallbackCommand->Delete();
2198   myEventCallbackCommand->SetClientData( this );
2199   myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2200   myPriority = 0.0;
2201
2202   /* load resources for all available meshers */
2203   SMESH::InitAvailableHypotheses();
2204 }
2205
2206 //=============================================================================
2207 /*!
2208  *
2209  */
2210 //=============================================================================
2211 SMESHGUI::~SMESHGUI()
2212 {
2213 }
2214
2215 //=============================================================================
2216 /*!
2217  *
2218  */
2219 //=============================================================================
2220 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2221 {
2222   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2223   if( anApp )
2224     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2225   else
2226     return 0;
2227 }
2228
2229 //=============================================================================
2230 /*!
2231  *
2232  */
2233 //=============================================================================
2234 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2235 {
2236   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2237   if ( !resMgr )
2238     return false;
2239
2240   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
2241   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2242   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2243   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2244   return autoUpdate && !exceeded;
2245 }
2246
2247 //=============================================================================
2248 /*!
2249  *
2250  */
2251 //=============================================================================
2252 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2253                                 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2254 {
2255   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2256   if ( !resMgr )
2257     return false;
2258
2259   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update", false );
2260   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2261   bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2262
2263   SMESH::long_array_var info = theMesh->GetMeshInfo();
2264   long nbOdElems = info[SMDSEntity_0D];
2265   long nbEdges   = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2266   long nbFaces   = info[SMDSEntity_Triangle]   + info[SMDSEntity_Quad_Triangle]   + info[SMDSEntity_BiQuad_Triangle] +
2267                    info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2268                    info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2269   long nbVolumes = info[SMDSEntity_Tetra]   + info[SMDSEntity_Quad_Tetra] +
2270                    info[SMDSEntity_Hexa]    + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2271                    info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2272                    info[SMDSEntity_Penta]   + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2273                    info[SMDSEntity_Polyhedra] +
2274                    info[SMDSEntity_Hexagonal_Prism];
2275   long nbBalls   = info[SMDSEntity_Ball];
2276
2277   long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2278   *nbElements = requestedSize;
2279
2280   *entities = SMESH_Actor::eAllEntity;
2281   *hidden   = 0;
2282
2283   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2284
2285   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2286
2287   if ( incrementalLimit ) {
2288     long total     = 0;
2289
2290     if ( nbOdElems > 0 ) {
2291       if ( total + nbOdElems > updateLimit ) {
2292         *entities = *entities & ~SMESH_Actor::e0DElements;
2293         *hidden = *hidden | SMESH_Actor::e0DElements;
2294       }
2295       else
2296         exceeded = false;
2297     }
2298     total += nbOdElems;
2299
2300     if ( nbEdges > 0 ) {
2301       if ( total + nbEdges > updateLimit ) {
2302         *entities = *entities & ~SMESH_Actor::eEdges;
2303         *hidden = *hidden | SMESH_Actor::eEdges;
2304       }
2305       else
2306         exceeded = false;
2307     }
2308     total += nbEdges;
2309
2310     if ( nbFaces > 0 ) {
2311       if ( total + nbFaces > updateLimit ) {
2312         *entities = *entities & ~SMESH_Actor::eFaces;
2313         *hidden = *hidden | SMESH_Actor::eFaces;
2314       }
2315       else
2316         exceeded = false;
2317     }
2318     total += nbFaces;
2319
2320     if ( nbVolumes > 0 ) {
2321       if ( total + nbVolumes > updateLimit ) {
2322         *entities = *entities & ~SMESH_Actor::eVolumes;
2323         *hidden = *hidden | SMESH_Actor::eVolumes;
2324       }
2325       else
2326         exceeded = false;
2327     }
2328     total += nbVolumes;
2329
2330     if ( nbBalls > 0 ) {
2331       if ( total + nbBalls > updateLimit ) {
2332         *entities = *entities & ~SMESH_Actor::eBallElem;
2333         *hidden = *hidden | SMESH_Actor::eBallElem;
2334       }
2335       else
2336         exceeded = false;
2337     }
2338     total += nbBalls;
2339   }
2340
2341   return autoUpdate && !exceeded;
2342 }
2343
2344 //=============================================================================
2345 /*!
2346  *
2347  */
2348 //=============================================================================
2349 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2350 {
2351   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2352 }
2353
2354 //=============================================================================
2355 /*!
2356  *
2357  */
2358 //=============================================================================
2359 SMESHGUI* SMESHGUI::GetSMESHGUI()
2360 {
2361   SMESHGUI* smeshMod = 0;
2362   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2363   if ( app )
2364   {
2365     CAM_Module* module = app->module( "Mesh" );
2366     smeshMod = dynamic_cast<SMESHGUI*>( module );
2367   }
2368
2369   return smeshMod;
2370 }
2371
2372 extern "C"
2373 {
2374   Standard_EXPORT SMESHGUI* GetComponentGUI()
2375   {
2376     return SMESHGUI::GetSMESHGUI();
2377   }
2378 }
2379
2380 //=============================================================================
2381 /*!
2382  *
2383  */
2384 //=============================================================================
2385 void SMESHGUI::SetState(int aState)
2386 {
2387   myState = aState;
2388 }
2389
2390 //=============================================================================
2391 /*!
2392  *
2393  */
2394 //=============================================================================
2395 void SMESHGUI::ResetState()
2396 {
2397   myState = -1;
2398 }
2399
2400 //=============================================================================
2401 /*!
2402  *
2403  */
2404 //=============================================================================
2405 void SMESHGUI::EmitSignalDeactivateDialog()
2406 {
2407   emit SignalDeactivateActiveDialog();
2408 }
2409
2410 //=============================================================================
2411 /*!
2412  *
2413  */
2414 //=============================================================================
2415 void SMESHGUI::EmitSignalStudyFrameChanged()
2416 {
2417   emit SignalStudyFrameChanged();
2418 }
2419
2420 //=============================================================================
2421 /*!
2422  *
2423  */
2424 //=============================================================================
2425 void SMESHGUI::EmitSignalCloseAllDialogs()
2426 {
2427   emit SignalCloseAllDialogs();
2428 }
2429
2430 //=============================================================================
2431 /*!
2432  *
2433  */
2434 //=============================================================================
2435 void SMESHGUI::EmitSignalVisibilityChanged()
2436 {
2437   emit SignalVisibilityChanged();
2438 }
2439
2440 //=============================================================================
2441 /*!
2442  *
2443  */
2444 //=============================================================================
2445 void SMESHGUI::EmitSignalCloseView()
2446 {
2447   emit SignalCloseView();
2448 }
2449
2450 //=============================================================================
2451 /*!
2452  *
2453  */
2454 //=============================================================================
2455 void SMESHGUI::EmitSignalActivatedViewManager()
2456 {
2457   emit SignalActivatedViewManager();
2458 }
2459
2460 //=============================================================================
2461 /*!
2462  *
2463  */
2464 //=============================================================================
2465 QDialog *SMESHGUI::GetActiveDialogBox()
2466 {
2467   return myActiveDialogBox;
2468 }
2469
2470 //=============================================================================
2471 /*!
2472  *
2473  */
2474 //=============================================================================
2475 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2476 {
2477   myActiveDialogBox = (QDialog *) aDlg;
2478   return;
2479 }
2480
2481 //=============================================================================
2482 /*!
2483  *
2484  */
2485 //=============================================================================
2486 SUIT_Desktop* SMESHGUI::desktop()
2487 {
2488   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2489   if( app )
2490     return app->desktop();
2491   else
2492     return 0;
2493 }
2494
2495 //=============================================================================
2496 /*!
2497  *
2498  */
2499 //=============================================================================
2500 SalomeApp_Study* SMESHGUI::activeStudy()
2501 {
2502   SUIT_Application* app = SUIT_Session::session()->activeApplication();
2503   if( app )
2504     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2505   else
2506     return NULL;
2507 }
2508
2509 //=============================================================================
2510 /*!
2511  *
2512  */
2513 //=============================================================================
2514 void SMESHGUI::Modified( bool theIsUpdateActions )
2515 {
2516   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2517     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2518       appStudy->Modified();
2519       if( theIsUpdateActions )
2520         app->updateActions();
2521     }
2522   }
2523 }
2524
2525 //=============================================================================
2526 /*!
2527  *
2528  */
2529 //=============================================================================
2530 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2531 {
2532   /* Here the position is on the bottom right corner - 10 */
2533   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2534   aDlg->adjustSize();
2535   SUIT_Desktop *PP = desktop();
2536   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2537   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2538   return true;
2539 }
2540
2541 /*!
2542  * \brief Verifies whether study of operation is locked
2543   * \param theMess - specifies whether message box must be shown if study is locked
2544   * \return State of study.
2545 *
2546 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2547 * is locked when corresponding message box appears
2548 */
2549 bool SMESHGUI::isStudyLocked( bool theMessage )
2550 {
2551   if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2552   {
2553     if ( theMessage )
2554       SUIT_MessageBox::warning( SMESHGUI::desktop(),
2555                                 QObject::tr( "WRN_WARNING" ),
2556                                 QObject::tr( "WRN_STUDY_LOCKED" ) );
2557     return true;
2558   }
2559   return false;
2560 }
2561
2562 //=============================================================================
2563 /*!
2564  *
2565  */
2566 //=============================================================================
2567 bool SMESHGUI::OnGUIEvent( int theCommandID )
2568 {
2569   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2570   if( !anApp )
2571     return false;
2572
2573   SUIT_ResourceMgr* mgr = resourceMgr();
2574   if( !mgr )
2575     return false;
2576
2577   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2578   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2579
2580   //QAction* act = action( theCommandID );
2581
2582   switch (theCommandID) {
2583   case SMESHOp::OpDelete:
2584     if(isStudyLocked()) break;
2585     OnEditDelete();
2586     break;
2587   case SMESHOp::OpImportDAT:
2588   case SMESHOp::OpImportUNV:
2589   case SMESHOp::OpImportMED:
2590   case SMESHOp::OpImportSTL:
2591   case SMESHOp::OpImportCGNS:
2592   case SMESHOp::OpImportSAUV:
2593   case SMESHOp::OpImportGMF:
2594   case SMESHOp::OpPopupImportDAT:
2595   case SMESHOp::OpPopupImportUNV:
2596   case SMESHOp::OpPopupImportMED:
2597   case SMESHOp::OpPopupImportSTL:
2598   case SMESHOp::OpPopupImportCGNS:
2599   case SMESHOp::OpPopupImportSAUV:
2600   case SMESHOp::OpPopupImportGMF:
2601     {
2602       if(isStudyLocked()) break;
2603       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2604       break;
2605     }
2606
2607   case SMESHOp::OpFileInformation:
2608     {
2609       SALOME_ListIO selected;
2610       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2611       if( aSel )
2612         aSel->selectedObjects( selected );
2613       if( selected.Extent() )
2614       {
2615         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2616         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2617         if ( !aMesh->_is_nil() )
2618         {
2619           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2620           dlg.exec();
2621         }
2622       }
2623       break;
2624     }
2625   case SMESHOp::OpExportDAT:
2626   case SMESHOp::OpExportMED:
2627   case SMESHOp::OpExportUNV:
2628   case SMESHOp::OpExportSTL:
2629   case SMESHOp::OpExportCGNS:
2630   case SMESHOp::OpExportSAUV:
2631   case SMESHOp::OpExportGMF:
2632   case SMESHOp::OpPopupExportDAT:
2633   case SMESHOp::OpPopupExportMED:
2634   case SMESHOp::OpPopupExportUNV:
2635   case SMESHOp::OpPopupExportSTL:
2636   case SMESHOp::OpPopupExportCGNS:
2637   case SMESHOp::OpPopupExportSAUV:
2638   case SMESHOp::OpPopupExportGMF:
2639     {
2640       ::ExportMeshToFile(theCommandID);
2641       break;
2642     }
2643
2644   case SMESHOp::OpReset:                      // SCALAR BAR
2645     {
2646       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2647       SALOME_ListIO selected;
2648       if( aSel )
2649         aSel->selectedObjects( selected );
2650
2651       SALOME_ListIteratorOfListIO it(selected);
2652       for( ; it.More(); it.Next()) {
2653         Handle(SALOME_InteractiveObject) anIO = it.Value();
2654         if( anIO->hasEntry() ) {
2655           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2656             anActor->SetControlMode( SMESH_Actor::eNone );
2657 #ifndef DISABLE_PLOT2DVIEWER
2658             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2659 #endif
2660             anActor->UpdateFilter();
2661           }
2662         }
2663       }
2664       SMESH::UpdateView();
2665       break;
2666     }
2667   case SMESHOp::OpScalarBarProperties:
2668     {
2669       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2670       break;
2671     }
2672   case SMESHOp::OpShowScalarBar:
2673     {
2674       // show/hide scalar bar
2675       ::ShowElement(theCommandID);
2676       break;
2677     }
2678   case SMESHOp::OpSaveDistribution:
2679     {
2680       // dump control distribution data to the text file
2681       ::SaveDistribution();
2682       break;
2683     }
2684
2685   case SMESHOp::OpShowDistribution:
2686     {
2687       // show/hide distribution
2688       ::ShowElement(theCommandID);
2689       break;
2690     }
2691
2692 #ifndef DISABLE_PLOT2DVIEWER
2693   case SMESHOp::OpPlotDistribution:
2694     {
2695       // plot distribution
2696       ::PlotDistribution();
2697       break;
2698     }
2699 #endif
2700
2701     // Auto-color
2702   case SMESHOp::OpAutoColor:
2703     ::AutoColor();
2704   break;
2705
2706   case SMESHOp::OpDisableAutoColor:
2707     ::DisableAutoColor();
2708   break;
2709
2710   case SMESHOp::OpClipping:
2711   case SMESHOp::OpTransparency:
2712   case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2713
2714     // Display Mode
2715   case SMESHOp::OpDMWireframe:
2716   case SMESHOp::OpDMShading:
2717   case SMESHOp::OpDMNodes:
2718   case SMESHOp::OpDMShrink:
2719     ::SetDisplayMode(theCommandID, myMarkerMap);
2720   break;
2721
2722   //2D quadratic representation
2723   case SMESHOp::OpRepresentationLines:
2724   case SMESHOp::OpRepresentationArcs:
2725     ::SetDisplayMode(theCommandID, myMarkerMap);
2726   break;
2727
2728   // Display Entity
2729   case SMESHOp::OpDE0DElements:
2730   case SMESHOp::OpDEEdges:
2731   case SMESHOp::OpDEFaces:
2732   case SMESHOp::OpDEVolumes:
2733   case SMESHOp::OpDEBalls:
2734   case SMESHOp::OpDEAllEntity:
2735     ::SetDisplayEntity(theCommandID);
2736   break;
2737
2738   // Choose entities to be displayed
2739   case SMESHOp::OpDEChoose:
2740     {
2741       ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2742       break;
2743     }
2744
2745   case SMESHOp::OpOrientationOnFaces:
2746     {
2747       SUIT_OverrideCursor wc;
2748       LightApp_SelectionMgr* mgr = selectionMgr();
2749       SALOME_ListIO selected; mgr->selectedObjects( selected );
2750
2751       SALOME_ListIteratorOfListIO it(selected);
2752       for( ; it.More(); it.Next()) {
2753         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2754         if(anIObject->hasEntry()) {
2755           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2756             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2757           }
2758         }
2759       }
2760       break;
2761     }
2762
2763   case SMESHOp::OpUpdate:
2764     {
2765       if(isStudyLocked()) break;
2766       SUIT_OverrideCursor wc;
2767       try {
2768         OCC_CATCH_SIGNALS;
2769         SMESH::UpdateView();
2770       }
2771       catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2772         SMESH::OnVisuException();
2773       }
2774       catch (...) { // PAL16774 (Crash after display of many groups)
2775         SMESH::OnVisuException();
2776       }
2777
2778       SALOME_ListIO l;
2779       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2780       aSel->selectedObjects( l );
2781       aSel->setSelectedObjects( l );
2782       break;
2783     }
2784
2785   case SMESHOp::OpHide:
2786   case SMESHOp::OpShow:
2787   case SMESHOp::OpShowOnly:
2788     {
2789       SUIT_OverrideCursor wc;
2790       SMESH::EDisplaing anAction;
2791       switch (theCommandID) {
2792       case SMESHOp::OpHide:     anAction = SMESH::eErase; break;
2793       case SMESHOp::OpShow:     anAction = SMESH::eDisplay; break;
2794       case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2795       }
2796
2797       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2798       SALOME_ListIO sel_objects, to_process;
2799       if (aSel)
2800         aSel->selectedObjects( sel_objects );
2801
2802       if ( theCommandID==SMESHOp::OpShowOnly )
2803       {
2804         //MESSAGE("anAction = SMESH::eDisplayOnly");
2805         startOperation( myEraseAll );
2806       }
2807
2808       extractContainers( sel_objects, to_process );
2809
2810       try {
2811         OCC_CATCH_SIGNALS;
2812         if (vtkwnd) {
2813           SALOME_ListIteratorOfListIO It( to_process );
2814           for ( ; It.More(); It.Next())
2815           {
2816             Handle(SALOME_InteractiveObject) IOS = It.Value();
2817             if ( IOS->hasEntry() )
2818             {
2819               if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2820                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2821                 break; // PAL16774 (Crash after display of many groups)
2822               }
2823               if (anAction == SMESH::eDisplayOnly)
2824                 anAction = SMESH::eDisplay;
2825             }
2826           }
2827         }
2828
2829         // PAL13338 + PAL15161 -->
2830         if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2831           SMESH::UpdateView();
2832           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2833         }
2834         // PAL13338 + PAL15161 <--
2835       }
2836       catch (...) { // PAL16774 (Crash after display of many groups)
2837         SMESH::OnVisuException();
2838       }
2839
2840       if (anAction == SMESH::eErase) {
2841         SALOME_ListIO l1;
2842         aSel->setSelectedObjects( l1 );
2843       }
2844       else
2845         aSel->setSelectedObjects( to_process );
2846
2847       if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2848            ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2849         vtkwnd->GetRenderer()->AdjustActors();
2850
2851       break;
2852     }
2853
2854   case SMESHOp::OpNode:
2855     {
2856       if(isStudyLocked()) break;
2857
2858       if ( vtkwnd ) {
2859         EmitSignalDeactivateDialog();
2860
2861         ( new SMESHGUI_NodesDlg( this ) )->show();
2862       }
2863       else {
2864         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2865       }
2866       break;
2867     }
2868
2869   case SMESHOp::OpEditMeshOrSubMesh:
2870   case SMESHOp::OpEditMesh:
2871   case SMESHOp::OpEditSubMesh:
2872   case SMESHOp::OpMeshOrder:
2873   case SMESHOp::OpCreateSubMesh:
2874     if ( warnOnGeomModif() )
2875       break; // action forbidden as geometry modified
2876     // fall through
2877   case SMESHOp::OpCreateMesh:
2878   case SMESHOp::OpCompute:
2879   case SMESHOp::OpComputeSubMesh:
2880   case SMESHOp::OpPreCompute:
2881   case SMESHOp::OpEvaluate:
2882   case SMESHOp::OpShowErrors:
2883     startOperation( theCommandID );
2884     break;
2885   case SMESHOp::OpRecompute:
2886     {
2887       if ( isStudyLocked() )
2888         break;
2889       SALOME_ListIO selected;
2890       if ( LightApp_SelectionMgr *sel = selectionMgr() )
2891         sel->selectedObjects( selected );
2892       if ( selected.Extent() == 1 ) {
2893         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2894         if ( !aMesh->_is_nil() )
2895           aMesh->Clear();
2896         startOperation( SMESHOp::OpCompute );
2897       }
2898     }
2899     break;
2900   case SMESHOp::OpCopyMesh:
2901     {
2902       if (isStudyLocked()) break;
2903       EmitSignalDeactivateDialog();
2904       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2905     }
2906     break;
2907   case SMESHOp::OpBuildCompoundMesh:
2908     {
2909       if (isStudyLocked()) break;
2910       EmitSignalDeactivateDialog();
2911       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2912     }
2913     break;
2914
2915   case SMESHOp::OpDiagonalInversion:
2916   case SMESHOp::OpUnionOfTwoTriangle:
2917     {
2918       if ( !vtkwnd )
2919       {
2920         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2921         break;
2922       }
2923
2924       if ( isStudyLocked() )
2925         break;
2926       if ( warnOnGeomModif() )
2927         break; // action forbidden as geometry modified
2928
2929       /*Standard_Boolean aRes;
2930       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2931       if ( aMesh->_is_nil() )
2932       {
2933         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2934           tr( "SMESH_BAD_SELECTION" ) );
2935         break;
2936       }
2937       */
2938       EmitSignalDeactivateDialog();
2939       if ( theCommandID == SMESHOp::OpDiagonalInversion )
2940         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2941       else
2942         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2943       break;
2944     }
2945   case SMESHOp::OpOrientation:
2946   case SMESHOp::OpUnionOfTriangles:
2947   case SMESHOp::OpCuttingOfQuadrangles:
2948   case SMESHOp::OpSplitVolumes:
2949     {
2950       if ( !vtkwnd )
2951       {
2952         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2953         break;
2954       }
2955
2956       if ( isStudyLocked() )
2957         break;
2958       if ( warnOnGeomModif() )
2959         break; // action forbidden as geometry modified
2960
2961       EmitSignalDeactivateDialog();
2962       SMESHGUI_MultiEditDlg* aDlg = NULL;
2963       if ( theCommandID == SMESHOp::OpOrientation )
2964         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2965       else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2966         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2967       else if ( theCommandID == SMESHOp::OpSplitVolumes )
2968         aDlg = new SMESHGUI_SplitVolumesDlg(this);
2969       else
2970         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2971
2972       aDlg->show();
2973       break;
2974     }
2975   case SMESHOp::OpSmoothing:
2976     {
2977       if(isStudyLocked()) break;
2978       if ( warnOnGeomModif() )
2979         break; // action forbidden as geometry modified
2980       if( vtkwnd ) {
2981         EmitSignalDeactivateDialog();
2982         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2983       }
2984       else {
2985         SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2986       }
2987       break;
2988     }
2989   case SMESHOp::OpExtrusion:
2990     {
2991       if (isStudyLocked()) break;
2992       if ( warnOnGeomModif() )
2993         break; // action forbidden as geometry modified
2994       if (vtkwnd) {
2995         EmitSignalDeactivateDialog();
2996         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2997       } else {
2998         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2999       }
3000       break;
3001     }
3002   case SMESHOp::OpExtrusionAlongAPath:
3003     {
3004       if (isStudyLocked()) break;
3005       if ( warnOnGeomModif() )
3006         break; // action forbidden as geometry modified
3007       if (vtkwnd) {
3008         EmitSignalDeactivateDialog();
3009         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3010       } else {
3011         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3012       }
3013       break;
3014     }
3015   case SMESHOp::OpRevolution:
3016     {
3017       if(isStudyLocked()) break;
3018       if ( warnOnGeomModif() )
3019         break; // action forbidden as geometry modified
3020       if( vtkwnd ) {
3021         EmitSignalDeactivateDialog();
3022         ( new SMESHGUI_RevolutionDlg( this ) )->show();
3023       }
3024       else {
3025         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3026       }
3027       break;
3028     }
3029   case SMESHOp::OpPatternMapping:
3030     {
3031       if ( isStudyLocked() )
3032         break;
3033       if ( warnOnGeomModif() )
3034         break; // action forbidden as geometry modified
3035       if ( vtkwnd )
3036       {
3037         EmitSignalDeactivateDialog();
3038         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3039       }
3040       else {
3041         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3042       }
3043       break;
3044     }
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   createSMESHAction( SMESHOp::OpMinimumDistance,  "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4283   createSMESHAction( SMESHOp::OpBoundingBox,      "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
4284   createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH",   "ICON_MEASURE_LENGTH" );
4285   createSMESHAction( SMESHOp::OpPropertiesArea,   "MEASURE_AREA",     "ICON_MEASURE_AREA" );
4286   createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME",   "ICON_MEASURE_VOLUME" );
4287   createSMESHAction( SMESHOp::OpAngle,            "MEASURE_ANGLE",    "ICON_MEASURE_ANGLE" );
4288
4289   createSMESHAction( SMESHOp::OpHide,     "HIDE", "ICON_HIDE" );
4290   createSMESHAction( SMESHOp::OpShow,     "SHOW", "ICON_SHOW" );
4291   createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4292
4293   createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4294
4295   createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4296
4297   QList<int> aCtrlActions;
4298   aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4299                << SMESHOp::OpNodeConnectivityNb                                         // node controls
4300                << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4301                << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge    // edge controls
4302                << SMESHOp::OpDeflection2D
4303                << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4304                << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4305                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4306                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4307                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
4308                << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4309                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4310                << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
4311   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4312   aCtrlGroup->setExclusive( true );
4313   for( int i = 0; i < aCtrlActions.size(); i++ )
4314     aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4315
4316   // ----- create menu --------------
4317   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
4318       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
4319       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
4320       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
4321       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
4322       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
4323       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4324       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
4325
4326   createMenu( separator(), fileId );
4327
4328   QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4329   QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4330   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4331       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4332       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4333       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4334       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4335       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4336       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
4337       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4338     //renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
4339       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4340       basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4341
4342   //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4343   createMenu( SMESHOp::OpImportUNV,  importId, -1 );
4344   createMenu( SMESHOp::OpImportMED,  importId, -1 );
4345   createMenu( SMESHOp::OpImportSTL,  importId, -1 );
4346 #ifdef WITH_CGNS
4347   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4348 #endif
4349   createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4350   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
4351   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
4352   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
4353   createMenu( SMESHOp::OpExportUNV,  exportId, -1 );
4354   createMenu( SMESHOp::OpExportSTL,  exportId, -1 );
4355 #ifdef WITH_CGNS
4356   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4357 #endif
4358   createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4359   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
4360   createMenu( separator(), fileId, 10 );
4361
4362   createMenu( SMESHOp::OpDelete, editId, -1 );
4363
4364   createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4365
4366   createMenu( SMESHOp::OpCreateMesh,           meshId, -1 ); // "Mesh" menu
4367   createMenu( SMESHOp::OpCreateSubMesh,        meshId, -1 );
4368   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
4369   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
4370   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
4371   createMenu( separator(),                     meshId, -1 );
4372   createMenu( SMESHOp::OpCompute,              meshId, -1 );
4373   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
4374   createMenu( SMESHOp::OpEvaluate,             meshId, -1 );
4375   createMenu( SMESHOp::OpMeshOrder,            meshId, -1 );
4376   createMenu( separator(),                     meshId, -1 );
4377   createMenu( SMESHOp::OpCreateGroup,          meshId, -1 );
4378   createMenu( SMESHOp::OpCreateGeometryGroup,  meshId, -1 );
4379   createMenu( SMESHOp::OpConstructGroup,       meshId, -1 );
4380   createMenu( SMESHOp::OpEditGroup,            meshId, -1 );
4381   createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4382   createMenu( separator(),                     meshId, -1 );
4383   createMenu( SMESHOp::OpUnionGroups,          meshId, -1 );
4384   createMenu( SMESHOp::OpIntersectGroups,      meshId, -1 );
4385   createMenu( SMESHOp::OpCutGroups,            meshId, -1 );
4386   createMenu( separator(),                     meshId, -1 );
4387   createMenu( SMESHOp::OpGroupUnderlyingElem,  meshId, -1 );
4388   createMenu( SMESHOp::OpFaceGroupsByEdges,    meshId, -1 );
4389   createMenu( separator(),                     meshId, -1 );
4390   createMenu( SMESHOp::OpMeshInformation,      meshId, -1 );
4391   //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4392   //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4393   createMenu( SMESHOp::OpFindElementByPoint,   meshId, -1 );
4394   createMenu( separator(),                     meshId, -1 );
4395
4396   createMenu( SMESHOp::OpFreeNode,              nodeId,   -1 );
4397   createMenu( SMESHOp::OpEqualNode,             nodeId,   -1 );
4398   //createMenu( SMESHOp::OpNodeConnectivityNb,    nodeId,   -1 );
4399   createMenu( SMESHOp::OpFreeBorder,            edgeId,   -1 );
4400   createMenu( SMESHOp::OpLength,                edgeId,   -1 );
4401   createMenu( SMESHOp::OpConnection,            edgeId,   -1 );
4402   createMenu( SMESHOp::OpEqualEdge,             edgeId,   -1 );
4403   createMenu( SMESHOp::OpFreeEdge,              faceId,   -1 );
4404   createMenu( SMESHOp::OpFreeFace,              faceId,   -1 );
4405   createMenu( SMESHOp::OpBareBorderFace,        faceId,   -1 );
4406   createMenu( SMESHOp::OpOverConstrainedFace,   faceId,   -1 );
4407   createMenu( SMESHOp::OpLength2D,              faceId,   -1 );
4408   createMenu( SMESHOp::OpConnection2D,          faceId,   -1 );
4409   createMenu( SMESHOp::OpArea,                  faceId,   -1 );
4410   createMenu( SMESHOp::OpTaper,                 faceId,   -1 );
4411   createMenu( SMESHOp::OpAspectRatio,           faceId,   -1 );
4412   createMenu( SMESHOp::OpMinimumAngle,          faceId,   -1 );
4413   createMenu( SMESHOp::OpWarpingAngle,          faceId,   -1 );
4414   createMenu( SMESHOp::OpSkew,                  faceId,   -1 );
4415   createMenu( SMESHOp::OpMaxElementLength2D,    faceId,   -1 );
4416   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
4417   createMenu( SMESHOp::OpDeflection2D,          faceId,   -1 );
4418   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
4419   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
4420   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
4421   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
4422   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4423   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
4424   createMenu( separator(),                      ctrlId,   -1 );
4425   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
4426   createMenu( separator(),                      ctrlId,   -1 );
4427   createMenu( SMESHOp::OpOverallMeshQuality,    ctrlId,   -1 );
4428
4429   createMenu( SMESHOp::OpNode,                   addId, -1 );
4430   createMenu( SMESHOp::OpElem0D,                 addId, -1 );
4431   createMenu( SMESHOp::OpElem0DOnElemNodes,      addId, -1 );
4432   createMenu( SMESHOp::OpBall,                   addId, -1 );
4433   createMenu( SMESHOp::OpEdge,                   addId, -1 );
4434   createMenu( SMESHOp::OpTriangle,               addId, -1 );
4435   createMenu( SMESHOp::OpQuadrangle,             addId, -1 );
4436   createMenu( SMESHOp::OpPolygon,                addId, -1 );
4437   createMenu( SMESHOp::OpTetrahedron,            addId, -1 );
4438   createMenu( SMESHOp::OpHexahedron,             addId, -1 );
4439   createMenu( SMESHOp::OpPentahedron,            addId, -1 );
4440   createMenu( SMESHOp::OpPyramid,                addId, -1 );
4441   createMenu( SMESHOp::OpHexagonalPrism,         addId, -1 );
4442   createMenu( SMESHOp::OpPolyhedron,             addId, -1 );
4443   createMenu( separator(),                       addId, -1 );
4444   createMenu( SMESHOp::OpQuadraticEdge,          addId, -1 );
4445   createMenu( SMESHOp::OpQuadraticTriangle,      addId, -1 );
4446   createMenu( SMESHOp::OpBiQuadraticTriangle ,   addId, -1 );
4447   createMenu( SMESHOp::OpQuadraticQuadrangle,    addId, -1 );
4448   createMenu( SMESHOp::OpBiQuadraticQuadrangle,  addId, -1 );
4449   createMenu( SMESHOp::OpQuadraticPolygon,       addId, -1 );
4450   createMenu( SMESHOp::OpQuadraticTetrahedron,   addId, -1 );
4451   createMenu( SMESHOp::OpQuadraticPyramid,       addId, -1 );
4452   createMenu( SMESHOp::OpQuadraticPentahedron,   addId, -1 );
4453   createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4454   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
4455   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4456
4457   createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
4458   createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
4459   createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4460   createMenu( separator(),                  removeId, -1 );
4461   createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
4462   createMenu( separator(),                  removeId, -1 );
4463   createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
4464
4465   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
4466   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4467
4468   createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
4469   createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
4470   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
4471   createMenu( SMESHOp::OpRotation,       transfId, -1 );
4472   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
4473   createMenu( SMESHOp::OpScale,          transfId, -1 );
4474   createMenu( SMESHOp::OpOffset,         transfId, -1 );
4475   createMenu( SMESHOp::OpSewing,         transfId, -1 );
4476   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4477
4478   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4479   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4480   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
4481   createMenu( SMESHOp::OpExtrusionAlongAPath,    modifyId, -1 );
4482   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
4483   createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
4484   createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
4485   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
4486   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
4487   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
4488   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
4489   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
4490   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
4491   createMenu( SMESHOp::OpSplitBiQuadratic,       modifyId, -1 );
4492   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
4493   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
4494
4495   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
4496   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
4497   createMenu( SMESHOp::OpAngle,            measureId,   -1 );
4498   createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4499   createMenu( SMESHOp::OpPropertiesArea,   basicPropId, -1 );
4500   createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4501   createMenu( SMESHOp::OpUpdate,           viewId,      -1 );
4502
4503   connect( nodeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4504   connect( edgeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4505   connect( faceMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4506   connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4507
4508   // ----- create toolbars --------------
4509   int meshTb       = createTool( tr( "TB_MESH" ),      QString( "SMESHMeshToolbar" ) ),
4510       info         = createTool( tr( "TB_INFO" ),      QString( "SMESHInformationToolbar" ) ),
4511       groupTb      = createTool( tr( "TB_GROUP" ),     QString( "SMESHGroupToolbar" ) ),
4512       ctrl0dTb     = createTool( tr( "TB_CTRL0D" ),    QString( "SMESHNodeControlsToolbar" ) ),
4513       ctrl1dTb     = createTool( tr( "TB_CTRL1D" ),    QString( "SMESHEdgeControlsToolbar" ) ),
4514       ctrl2dTb     = createTool( tr( "TB_CTRL2D" ),    QString( "SMESHFaceControlsToolbar" ) ),
4515       ctrl3dTb     = createTool( tr( "TB_CTRL3D" ),    QString( "SMESHVolumeControlsToolbar" ) ),
4516       addElemTb    = createTool( tr( "TB_ADD" ),       QString( "SMESHAddElementToolbar" ) ),
4517       addNonElemTb = createTool( tr( "TB_ADDNON" ),    QString( "SMESHAddElementToolbar" ) ),
4518       remTb        = createTool( tr( "TB_REM" ),       QString( "SMESHRemoveToolbar" ) ),
4519     //renumbTb     = createTool( tr( "TB_RENUMBER" ),  QString( "SMESHRenumberingToolbar" ) ),
4520       transformTb  = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4521       modifyTb     = createTool( tr( "TB_MODIFY" ),    QString( "SMESHModificationToolbar" ) ),
4522       measuremTb   = createTool( tr( "TB_MEASUREM" ),  QString( "SMESHMeasurementsToolbar" ) ),
4523       dispModeTb   = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4524
4525   createTool( SMESHOp::OpCreateMesh,        meshTb );
4526   createTool( SMESHOp::OpCreateSubMesh,     meshTb );
4527   createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4528   createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4529   createTool( SMESHOp::OpCopyMesh,          meshTb );
4530   createTool( separator(),                  meshTb );
4531   createTool( SMESHOp::OpCompute,           meshTb );
4532   createTool( SMESHOp::OpPreCompute,        meshTb );
4533   createTool( SMESHOp::OpEvaluate,          meshTb );
4534   createTool( SMESHOp::OpMeshOrder,         meshTb );
4535
4536   createTool( SMESHOp::OpCreateGroup,         groupTb );
4537   createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4538   createTool( SMESHOp::OpConstructGroup,      groupTb );
4539   createTool( SMESHOp::OpEditGroup,           groupTb );
4540
4541   createTool( SMESHOp::OpMeshInformation,    info );
4542   //createTool( SMESHOp::OpStdInfo, meshTb );
4543   //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4544   createTool( SMESHOp::OpFindElementByPoint, info );
4545
4546   createTool( SMESHOp::OpFreeNode,  ctrl0dTb );
4547   createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4548   //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4549
4550   createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4551   createTool( SMESHOp::OpLength,     ctrl1dTb );
4552   createTool( SMESHOp::OpConnection, ctrl1dTb );
4553   createTool( SMESHOp::OpEqualEdge,  ctrl1dTb );
4554
4555   createTool( SMESHOp::OpFreeEdge,            ctrl2dTb );
4556   createTool( SMESHOp::OpFreeFace,            ctrl2dTb );
4557   createTool( SMESHOp::OpBareBorderFace,      ctrl2dTb );
4558   createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4559   createTool( SMESHOp::OpLength2D,            ctrl2dTb );
4560   createTool( SMESHOp::OpConnection2D,        ctrl2dTb );
4561   createTool( SMESHOp::OpArea,                ctrl2dTb );
4562   createTool( SMESHOp::OpTaper,               ctrl2dTb );
4563   createTool( SMESHOp::OpAspectRatio,         ctrl2dTb );
4564   createTool( SMESHOp::OpMinimumAngle,        ctrl2dTb );
4565   createTool( SMESHOp::OpWarpingAngle,        ctrl2dTb );
4566   createTool( SMESHOp::OpSkew,                ctrl2dTb );
4567   createTool( SMESHOp::OpMaxElementLength2D,  ctrl2dTb );
4568   createTool( SMESHOp::OpEqualFace,           ctrl2dTb );
4569   createTool( SMESHOp::OpDeflection2D,        ctrl2dTb );
4570
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   createTool( SMESHOp::OpNode,              addElemTb );
4579   createTool( SMESHOp::OpElem0D,            addElemTb );
4580   createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4581   createTool( SMESHOp::OpBall,              addElemTb );
4582   createTool( SMESHOp::OpEdge,              addElemTb );
4583   createTool( SMESHOp::OpTriangle,          addElemTb );
4584   createTool( SMESHOp::OpQuadrangle,        addElemTb );
4585   createTool( SMESHOp::OpPolygon,           addElemTb );
4586   createTool( SMESHOp::OpTetrahedron,       addElemTb );
4587   createTool( SMESHOp::OpHexahedron,        addElemTb );
4588   createTool( SMESHOp::OpPentahedron,       addElemTb );
4589   createTool( SMESHOp::OpPyramid,           addElemTb );
4590   createTool( SMESHOp::OpHexagonalPrism,    addElemTb );
4591   createTool( SMESHOp::OpPolyhedron,        addElemTb );
4592
4593   createTool( SMESHOp::OpQuadraticEdge,          addNonElemTb );
4594   createTool( SMESHOp::OpQuadraticTriangle,      addNonElemTb );
4595   createTool( SMESHOp::OpBiQuadraticTriangle,    addNonElemTb );
4596   createTool( SMESHOp::OpQuadraticQuadrangle,    addNonElemTb );
4597   createTool( SMESHOp::OpBiQuadraticQuadrangle,  addNonElemTb );
4598   createTool( SMESHOp::OpQuadraticPolygon,       addNonElemTb );
4599   createTool( SMESHOp::OpQuadraticTetrahedron,   addNonElemTb );
4600   createTool( SMESHOp::OpQuadraticPyramid,       addNonElemTb );
4601   createTool( SMESHOp::OpQuadraticPentahedron,   addNonElemTb );
4602   createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4603   createTool( SMESHOp::OpQuadraticHexahedron,    addNonElemTb );
4604   createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4605
4606   createTool( SMESHOp::OpRemoveNodes,       remTb );
4607   createTool( SMESHOp::OpRemoveElements,    remTb );
4608   createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4609   createTool( SMESHOp::OpClearMesh,         remTb );
4610
4611   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
4612   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4613
4614   createTool( SMESHOp::OpMergeNodes,     transformTb );
4615   createTool( SMESHOp::OpMergeElements,  transformTb );
4616   createTool( SMESHOp::OpTranslation,    transformTb );
4617   createTool( SMESHOp::OpRotation,       transformTb );
4618   createTool( SMESHOp::OpSymmetry,       transformTb );
4619   createTool( SMESHOp::OpScale,          transformTb );
4620   createTool( SMESHOp::OpOffset,         transformTb );
4621   createTool( SMESHOp::OpSewing,         transformTb );
4622   createTool( SMESHOp::OpDuplicateNodes, transformTb );
4623
4624   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4625   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4626   createTool( SMESHOp::OpExtrusion,              modifyTb );
4627   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
4628   createTool( SMESHOp::OpRevolution,             modifyTb );
4629   createTool( SMESHOp::OpOrientation,            modifyTb );
4630   createTool( SMESHOp::OpReorientFaces,          modifyTb );
4631   createTool( SMESHOp::OpMoveNode,               modifyTb );
4632   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
4633   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
4634   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
4635   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
4636   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
4637   createTool( SMESHOp::OpSplitBiQuadratic,       modifyTb );
4638   createTool( SMESHOp::OpSmoothing,              modifyTb );
4639   createTool( SMESHOp::OpPatternMapping,         modifyTb );
4640
4641   createTool( SMESHOp::OpMinimumDistance, measuremTb );
4642
4643   createTool( SMESHOp::OpUpdate, dispModeTb );
4644
4645   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4646   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4647
4648   myRules.clear();
4649   QString
4650     OB      = "'ObjectBrowser'",
4651     View    = "'" + SVTK_Viewer::Type() + "'",
4652     pat     = "'%1'",
4653     mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4654     group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4655     hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4656     algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4657     smesh   = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4658     elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4659     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4660     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4661     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4662     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4663     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4664     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4665     subMesh      = elems,
4666     mesh_part    = mesh + " " + subMesh + " " + group,
4667     mesh_group   = mesh + " " + group,
4668     mesh_submesh = mesh + " " + subMesh,
4669     hyp_alg      = hypo + " " + algo;
4670
4671   // popup for object browser
4672   QString
4673     isInvisible("not( isVisible )"),
4674     isEmpty("numberOfNodes = 0"),
4675     isNotEmpty("numberOfNodes <> 0"),
4676
4677     // has nodes, edges, etc in VISIBLE! actor
4678     hasNodes("(numberOfNodes > 0 ) && hasActor"),
4679     hasElems("(count( elemTypes ) > 0)"),
4680     hasDifferentElems("(count( elemTypes ) > 1)"),
4681     hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4682     hasBalls("({'BallElem'} in elemTypes)"),
4683     hasElems0d("({'Elem0d'} in elemTypes)"),
4684     hasEdges("({'Edge'} in elemTypes)"),
4685     hasFaces("({'Face'} in elemTypes)"),
4686     hasVolumes("({'Volume'} in elemTypes)"),
4687     hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4688
4689   createPopupItem( SMESHOp::OpEditMesh,          OB, mesh, "&& selcount=1" );
4690   createPopupItem( SMESHOp::OpCreateSubMesh,     OB, mesh, "&& hasGeomReference");
4691   createPopupItem( SMESHOp::OpMeshOrder,         OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4692   createPopupItem( SMESHOp::OpEditSubMesh,       OB, subMesh, "&& selcount=1 && hasGeomReference" );
4693   createPopupItem( SMESHOp::OpEditGroup,         OB, group );
4694   createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4695
4696   popupMgr()->insert( separator(), -1, 0 );
4697   createPopupItem( SMESHOp::OpCompute,           OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4698   createPopupItem( SMESHOp::OpRecompute,         OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4699   createPopupItem( SMESHOp::OpShowErrors,        OB, mesh, "&& selcount=1 && hasErrors" );
4700   createPopupItem( SMESHOp::OpComputeSubMesh,    OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4701   createPopupItem( SMESHOp::OpPreCompute,        OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4702   createPopupItem( SMESHOp::OpEvaluate,          OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4703   popupMgr()->insert( separator(), -1, 0 );
4704   createPopupItem( SMESHOp::OpFileInformation,   OB, mesh, "&& selcount=1 && isImported" );
4705   createPopupItem( SMESHOp::OpMeshInformation,   OB, mesh_part );
4706   createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4707   createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4708   popupMgr()->insert( separator(), -1, 0 );
4709   createPopupItem( SMESHOp::OpCreateGroup,       OB, mesh, "&& selcount=1" );
4710   createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4711   createPopupItem( SMESHOp::OpConstructGroup,    OB, subMesh );
4712   popupMgr()->insert( separator(), -1, 0 );
4713   createPopupItem( SMESHOp::OpEditHypothesis,    OB, hypo, "&& isEditableHyp");
4714   createPopupItem( SMESHOp::OpUnassign,          OB, hyp_alg );
4715   popupMgr()->insert( separator(), -1, 0 );
4716   createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4717   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4718   //popupMgr()->insert( separator(), -1, 0 );
4719
4720   //popupMgr()->insert( separator(), -1, 0 );
4721
4722   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4723   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4724   QString only_one_2D        = only_one_non_empty + " && dim>1";
4725
4726   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4727   popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4728   createPopupItem( SMESHOp::OpPopupExportMED,  OB, mesh_group, multiple_non_empty, anId );
4729   createPopupItem( SMESHOp::OpPopupExportUNV,  OB, mesh_group, only_one_non_empty, anId );
4730   createPopupItem( SMESHOp::OpPopupExportSTL,  OB, mesh_group, only_one_2D, anId );
4731 #ifdef WITH_CGNS
4732   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4733 #endif
4734   createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4735   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, only_one_non_empty, anId );
4736   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, only_one_non_empty, anId );
4737
4738   anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 );        // IMPORT submenu
4739   createPopupItem( SMESHOp::OpPopupImportMED,  OB, smesh, "", anId );
4740   createPopupItem( SMESHOp::OpPopupImportUNV,  OB, smesh, "", anId );
4741   createPopupItem( SMESHOp::OpPopupImportSTL,  OB, smesh, "", anId );
4742 #ifdef WITH_CGNS
4743   createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4744 #endif
4745   createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4746   createPopupItem( SMESHOp::OpPopupImportGMF,  OB, smesh, "", anId );
4747   createPopupItem( SMESHOp::OpPopupImportDAT,  OB, smesh, "", anId );
4748   popupMgr()->insert( separator(), -1, 0 );
4749
4750   createPopupItem( SMESHOp::OpClearMesh,         OB, mesh );
4751   createPopupItem( SMESHOp::OpDelete,            OB, mesh_part + " " + hyp_alg );
4752   createPopupItem( SMESHOp::OpDeleteGroup,       OB, group );
4753
4754   // popup for viewer
4755   createPopupItem( SMESHOp::OpEditGroup,            View, group );
4756   createPopupItem( SMESHOp::OpAddElemGroupPopup,    View, elems, "&& guiState = 800" );
4757   createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4758
4759   popupMgr()->insert( separator(), -1, 0 );
4760   createPopupItem( SMESHOp::OpMeshInformation,    View, mesh_part );
4761   createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4762   createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4763   popupMgr()->insert( separator(), -1, 0 );
4764
4765   createPopupItem( SMESHOp::OpUpdate,           OB + " " + View, mesh_part );
4766   createPopupItem( SMESHOp::OpAutoColor,        OB + " " + View, mesh, "&& (not isAutoColor)" );
4767   createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4768   popupMgr()->insert( separator(), -1, 0 );
4769
4770   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4771   QString aType = QString( "%1type in {%2}" ).arg( lc );
4772   aType = aType.arg( mesh_part );
4773   QString aMeshInVTK = aClient + "&&" + aType;
4774
4775   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4776   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4777   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4778
4779   //-------------------------------------------------
4780   // Numbering
4781   //-------------------------------------------------
4782   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4783
4784   popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4785   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4786   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4787
4788   popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4789   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4790   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4791
4792   popupMgr()->insert( separator(), -1, -1 );
4793
4794   //-------------------------------------------------
4795   // Display Mode
4796   //-------------------------------------------------
4797   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4798
4799   popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4800   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4801   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4802
4803   popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4804   popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4805   popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4806
4807   popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4808   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4809   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4810
4811   popupMgr()->insert( separator(), anId, -1 );
4812
4813   popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4814   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4815   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4816
4817   //-------------------------------------------------
4818   // Display Entity
4819   //-------------------------------------------------
4820   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4821
4822   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4823
4824   popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4825   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4826   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4827
4828   popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4829   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4830   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4831
4832   popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4833   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4834   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4835
4836   popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4837   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4838   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4839
4840   popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4841   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4842   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4843
4844   popupMgr()->insert( separator(), anId, -1 );
4845
4846   popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4847   popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4848
4849   popupMgr()->insert( separator(), anId, -1 );
4850
4851   popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4852   popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4853
4854
4855   //-------------------------------------------------
4856   // Representation of the 2D Quadratic elements
4857   //-------------------------------------------------
4858   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4859   popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4860   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4861   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4862
4863   popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4864   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4865   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4866
4867   //-------------------------------------------------
4868   // Orientation of faces
4869   //-------------------------------------------------
4870   popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4871   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4872   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4873
4874   //-------------------------------------------------
4875   // Color / Size
4876   //-------------------------------------------------
4877   popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4878   popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4879
4880   //-------------------------------------------------
4881   // Transparency
4882   //-------------------------------------------------
4883   popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4884   popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4885
4886   //-------------------------------------------------
4887   // Controls
4888   //-------------------------------------------------
4889   QString
4890     aMeshInVtkHasNodes   = aMeshInVTK + "&&" + hasNodes,
4891     aMeshInVtkHasEdges   = aMeshInVTK + "&&" + hasEdges,
4892     aMeshInVtkHasFaces   = aMeshInVTK + "&&" + hasFaces,
4893     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4894
4895   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4896
4897   popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4898   popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4899
4900   popupMgr()->insert( separator(), anId, -1 );
4901
4902   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4903
4904   popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4905   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4906   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4907
4908   popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4909   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4910   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4911
4912   // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4913   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4914   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4915
4916   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4917
4918   popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4919   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4920   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4921
4922   popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4923   popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4924   popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4925
4926   popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4927   popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4928   popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4929   popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4930   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4931   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4932
4933   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4934
4935   popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4936   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4937   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4938
4939   popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4940   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4941                                        QtxPopupMgr::VisibleRule );
4942   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4943
4944   popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4945   popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4946   popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4947
4948   popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4949   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4950   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4951
4952   popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4953   popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4954   popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4955
4956   popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4957   popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4958   popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4959
4960   popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4961   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4962   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4963
4964   popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4965   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4966   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4967
4968   popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4969   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4970   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4971
4972   popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4973   popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4974   popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4975
4976   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4977   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4978   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4979
4980   popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4981   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4982   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4983
4984   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4985   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4986   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4987
4988   popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4989   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4990   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4991
4992   popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4993   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4994   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4995
4996   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4997
4998   popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D  ), aSubId, -1 );
4999   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5000   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5001
5002   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5003   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5004   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5005
5006   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5007   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5008   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5009
5010   popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5011   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5012   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5013
5014   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5015   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5016   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5017
5018   popupMgr()->insert ( action( SMESHOp::OpEqualVolume  ), aSubId, -1 );
5019   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5020   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5021
5022   popupMgr()->insert( separator(), anId, -1 );
5023
5024   popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5025   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5026   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5027   popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5028   popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5029
5030   popupMgr()->insert( separator(), anId, -1 );
5031
5032   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5033
5034   popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5035   popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5036
5037   popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5038   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5039   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5040
5041 #ifndef DISABLE_PLOT2DVIEWER
5042   popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5043   popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5044 #endif
5045
5046   //-------------------------------------------------
5047   // Show / Hide
5048   //-------------------------------------------------
5049   popupMgr()->insert( separator(), -1, -1 );
5050   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5051     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5052   popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5053   popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5054
5055   popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5056   popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5057
5058   popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5059   popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5060
5061   popupMgr()->insert( separator(), -1, -1 );
5062
5063   //-------------------------------------------------
5064   // Clipping
5065   //-------------------------------------------------
5066   popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5067   popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5068
5069   popupMgr()->insert( separator(), -1, -1 );
5070
5071   popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5072   popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5073   popupMgr()->insert( separator(), -1, -1 );
5074
5075   popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5076   popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5077
5078   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5079            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5080
5081   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5082            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5083 }
5084
5085 //================================================================================
5086 /*!
5087  * \brief Return true if SMESH or GEOM objects are selected.
5088  * Is called form LightApp_Module::activateModule() which clear selection if
5089  * not isSelectionCompatible()
5090  */
5091 //================================================================================
5092
5093 bool SMESHGUI::isSelectionCompatible()
5094 {
5095   bool isCompatible = true;
5096   SALOME_ListIO selected;
5097   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5098     Sel->selectedObjects( selected );
5099
5100   SALOME_ListIteratorOfListIO It( selected );
5101   for ( ; isCompatible && It.More(); It.Next())
5102     isCompatible =
5103       ( strcmp("GEOM",        It.Value()->getComponentDataType()) == 0 ) ||
5104       ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5105       ( strcmp("SMESH",       It.Value()->getComponentDataType()) == 0 );
5106
5107   return isCompatible;
5108 }
5109
5110
5111 bool SMESHGUI::reusableOperation( const int id )
5112 {
5113   // compute, evaluate and precompute are not reusable operations
5114   return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5115 }
5116
5117 namespace
5118 {
5119   QString wrap(const QString& text, const QString& tag)
5120   { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5121 }
5122
5123 bool SMESHGUI::activateModule( SUIT_Study* study )
5124 {
5125   bool res = SalomeApp_Module::activateModule( study );
5126
5127   setMenuShown( true );
5128   setToolShown( true );
5129
5130   // Fill in Help Panel
5131   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5132   app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5133
5134   int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5135   QString lab;
5136   QStringList items;
5137   lab =       tr("INFO_DEFINE_ALGOS") + "<br/>";
5138   lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5139   lab = lab + tr("INFO_COMPUTE") + "<br/>";
5140   lab = lab + tr("INFO_REFINE") + ":";
5141   items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5142         << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5143   lab = lab + wrap(items.join(""), "ul");
5144   items.clear();
5145
5146   app->infoPanel()->addLabel(lab, gb);
5147
5148   gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5149   items << wrap("UNV", "li")
5150         << wrap("MED", "li")
5151         << wrap("STL", "li")
5152         << wrap("CGNS", "li")
5153         << wrap("SAUV", "li")
5154         << wrap("GMF", "li");
5155   lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5156   items.clear();
5157
5158   app->infoPanel()->addLabel(lab, gb);
5159
5160   gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5161   lab = tr("INFO_DISPLAY") + "<br/>";
5162   items << wrap(tr("INFO_QUALITY_AREA"), "li")
5163         << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5164         << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5165         << wrap("...", "li");
5166   lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5167   items.clear();
5168   lab = lab + tr("INFO_CLIPPING");
5169
5170   app->infoPanel()->addLabel(lab, gb);
5171   // << Help Panel
5172
5173   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5174   PyGILState_STATE gstate = PyGILState_Ensure();
5175   PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5176   if ( !pluginsmanager ) {
5177     PyErr_Print();
5178   }
5179   else {
5180     PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5181     if ( !result )
5182       PyErr_Print();
5183     Py_XDECREF(result);
5184   }
5185   PyGILState_Release(gstate);
5186   // end of SMESH plugins loading
5187
5188   // Reset actions accelerator keys
5189   action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5190
5191   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5192   GetSMESHGen()->UpdateStudy();
5193
5194   // get all view currently opened in the study and connect their signals  to
5195   // the corresponding slots of the class.
5196   SUIT_Desktop* aDesk = study->application()->desktop();
5197   if ( aDesk ) {
5198     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5199     SUIT_ViewWindow* wnd;
5200     foreach ( wnd, wndList )
5201     {
5202       connectView( wnd );
5203
5204       // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5205       SMESH::UpdateActorsAfterUpdateStudy(wnd);
5206
5207       wnd->update();
5208     }
5209   }
5210
5211   Py_XDECREF(pluginsmanager);
5212   return res;
5213 }
5214
5215 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5216 {
5217   setMenuShown( false );
5218   setToolShown( false );
5219
5220   EmitSignalCloseAllDialogs();
5221
5222   // Unset actions accelerator keys
5223   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5224
5225   return SalomeApp_Module::deactivateModule( study );
5226 }
5227
5228 void SMESHGUI::studyClosed( SUIT_Study* s )
5229 {
5230   if( !s )
5231     return;
5232   SMESH::RemoveVisuData();
5233   SalomeApp_Module::studyClosed( s );
5234 }
5235
5236 void SMESHGUI::OnGUIEvent()
5237 {
5238   const QObject* obj = sender();
5239   if ( !obj || !obj->inherits( "QAction" ) )
5240     return;
5241   int id = actionId((QAction*)obj);
5242   if ( id != -1 )
5243     OnGUIEvent( id );
5244 }
5245
5246 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5247 {
5248   if ( CORBA::is_nil( myComponentSMESH ) )
5249   {
5250     SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5251     return aGUI.myComponentSMESH;
5252   }
5253   return myComponentSMESH;
5254 }
5255
5256 QString SMESHGUI::engineIOR() const
5257 {
5258   CORBA::ORB_var anORB = getApp()->orb();
5259   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5260   return QString( anIOR.in() );
5261 }
5262
5263 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5264 {
5265   SalomeApp_Module::contextMenuPopup( client, menu, title );
5266   SALOME_ListIO lst;
5267   selectionMgr()->selectedObjects( lst );
5268   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5269     Handle(SALOME_InteractiveObject) io = lst.First();
5270     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5271     _PTR(Study) study = appStudy->studyDS();
5272     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5273     if ( obj ) {
5274       QString aName = SMESH::fromUtf8( obj->GetName());
5275       while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5276         aName.remove(( aName.length() - 1 ), 1 );
5277       title = aName;
5278     }
5279   }
5280 }
5281
5282 LightApp_Selection* SMESHGUI::createSelection() const
5283 {
5284   return new SMESHGUI_Selection();
5285 }
5286
5287 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5288 {
5289   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5290   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5291   aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5292 #ifndef DISABLE_PYCONSOLE
5293   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5294 #endif
5295 }
5296
5297 void SMESHGUI::viewManagers( QStringList& list ) const
5298 {
5299   list.append( SVTK_Viewer::Type() );
5300 }
5301
5302 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5303 {
5304   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5305     SMESH::UpdateSelectionProp( this );
5306
5307     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5308     for(int i = 0; i < aViews.count() ; i++){
5309       SUIT_ViewWindow *sf = aViews[i];
5310       connectView( sf );
5311     }
5312     EmitSignalActivatedViewManager();
5313   }
5314 }
5315
5316 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5317 {
5318   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5319     myClippingPlaneInfoMap.erase( theViewManager );
5320 }
5321
5322 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5323 {
5324   theActor->AddObserver( SMESH::DeleteActorEvent,
5325                          myEventCallbackCommand.GetPointer(),
5326                          myPriority );
5327 }
5328
5329 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5330                               unsigned long theEvent,
5331                               void* theClientData,
5332                               void* /*theCallData*/ )
5333 {
5334   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5335     if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5336       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5337         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5338         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5339         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5340           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5341           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5342           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5343             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5344             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5345             SMESH::TActorList::iterator anIter3 = anActorList.begin();
5346             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5347               if( anActor == *anIter3 ) {
5348                 anActorList.erase( anIter3 );
5349                 break;
5350               }
5351             }
5352           }
5353         }
5354       }
5355     }
5356   }
5357 }
5358
5359 void SMESHGUI::createPreferences()
5360 {
5361   // General tab ------------------------------------------------------------------------
5362   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5363
5364   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5365   setPreferenceProperty( autoUpdate, "columns", 2 );
5366   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5367   setPreferenceProperty( lim, "min",  0 );
5368   setPreferenceProperty( lim, "max",  100000000 );
5369   setPreferenceProperty( lim, "step", 1000 );
5370   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5371   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5372
5373   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5374   setPreferenceProperty( dispgroup, "columns", 2 );
5375
5376   addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5377
5378   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5379   QStringList modes;
5380   modes.append( tr("MEN_WIRE") );
5381   modes.append( tr("MEN_SHADE") );
5382   modes.append( tr("MEN_NODES") );
5383   modes.append( tr("MEN_SHRINK") );
5384   QList<QVariant> indices;
5385   indices.append( 0 );
5386   indices.append( 1 );
5387   indices.append( 2 );
5388   indices.append( 3 );
5389   setPreferenceProperty( dispmode, "strings", modes );
5390   setPreferenceProperty( dispmode, "indexes", indices );
5391
5392   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5393   setPreferenceProperty( arcgroup, "columns", 2 );
5394   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5395   QStringList quadraticModes;
5396   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5397   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5398   indices.clear();
5399   indices.append( 0 );
5400   indices.append( 1 );
5401   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5402   setPreferenceProperty( quadraticmode, "indexes", indices );
5403
5404   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5405                               "SMESH", "max_angle" );
5406   setPreferenceProperty( maxAngle, "min", 1 );
5407   setPreferenceProperty( maxAngle, "max", 90 );
5408
5409   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5410   setPreferenceProperty( qaGroup, "columns", 2 );
5411   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5412   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5413   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5414   setPreferenceProperty( prec, "min", 0 );
5415   setPreferenceProperty( prec, "max", 100 );
5416   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5417   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5418   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5419   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5420   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5421
5422   /*
5423   int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5424   setPreferenceProperty( cinc, "min", 0 );
5425   setPreferenceProperty( cinc, "max", 5 );
5426   */
5427
5428   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5429   setPreferenceProperty( exportgroup, "columns", 2 );
5430   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5431   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5432   int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5433   setPreferenceProperty( zTol, "precision", 10 );
5434   setPreferenceProperty( zTol, "min", 0.0000000001 );
5435   setPreferenceProperty( zTol, "max", 1000000.0 );
5436   setPreferenceProperty( zTol, "step", 1. );
5437   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5438
5439   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5440   setPreferenceProperty( computeGroup, "columns", 2 );
5441   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5442   modes.clear();
5443   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5444   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5445   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5446   indices.clear();
5447   indices.append( 0 );
5448   indices.append( 1 );
5449   indices.append( 2 );
5450   setPreferenceProperty( notifyMode, "strings", modes );
5451   setPreferenceProperty( notifyMode, "indexes", indices );
5452
5453   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5454   setPreferenceProperty( infoGroup, "columns", 2 );
5455   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5456   modes.clear();
5457   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5458   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5459   indices.clear();
5460   indices.append( 0 );
5461   indices.append( 1 );
5462   setPreferenceProperty( elemInfo, "strings", modes );
5463   setPreferenceProperty( elemInfo, "indexes", indices );
5464   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5465   setPreferenceProperty( nodesLim, "min", 0 );
5466   setPreferenceProperty( nodesLim, "max", 10000000 );
5467   setPreferenceProperty( nodesLim, "step", 10000 );
5468   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5469   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5470   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5471   setPreferenceProperty( ctrlLim, "min", 0 );
5472   setPreferenceProperty( ctrlLim, "max", 10000000 );
5473   setPreferenceProperty( ctrlLim, "step", 1000 );
5474   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5475   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5476   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5477   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5478   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5479
5480   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5481   setPreferenceProperty( segGroup, "columns", 2 );
5482   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5483                               "SMESH", "segmentation" );
5484   setPreferenceProperty( segLen, "min", 1 );
5485   setPreferenceProperty( segLen, "max", 10000000 );
5486   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5487                              "SMESH", "nb_segments_per_edge" );
5488   setPreferenceProperty( nbSeg, "min", 1 );
5489   setPreferenceProperty( nbSeg, "max", 10000000 );
5490   addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5491
5492   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5493   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5494                  "SMESH", "forget_mesh_on_hyp_modif" );
5495
5496
5497   // Quantities with individual precision settings
5498   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5499   setPreferenceProperty( precGroup, "columns", 2 );
5500
5501   const int nbQuantities = 6;
5502   int precs[nbQuantities], ii = 0;
5503   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5504                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5505   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5506                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5507   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5508                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5509   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5510                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5511   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5512                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5513   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5514                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5515
5516   // Set property for precision value for spinboxes
5517   for ( ii = 0; ii < nbQuantities; ii++ ){
5518     setPreferenceProperty( precs[ii], "min", -14 );
5519     setPreferenceProperty( precs[ii], "max", 14 );
5520     setPreferenceProperty( precs[ii], "precision", 2 );
5521   }
5522
5523   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5524   setPreferenceProperty( previewGroup, "columns", 2 );
5525   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5526   setPreferenceProperty( chunkSize, "min",  1 );
5527   setPreferenceProperty( chunkSize, "max",  1000 );
5528   setPreferenceProperty( chunkSize, "step", 50 );
5529
5530   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5531   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5532
5533   // Mesh tab ------------------------------------------------------------------------
5534   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5535   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5536   setPreferenceProperty( nodeGroup, "columns", 3 );
5537
5538   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5539
5540   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5541
5542   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5543   QList<QVariant> aMarkerTypeIndicesList;
5544   QList<QVariant> aMarkerTypeIconsList;
5545   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5546     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5547     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5548     aMarkerTypeIndicesList << i;
5549     aMarkerTypeIconsList << pixmap;
5550   }
5551   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5552   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5553
5554   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5555
5556   QList<QVariant> aMarkerScaleIndicesList;
5557   QStringList     aMarkerScaleValuesList;
5558   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5559     aMarkerScaleIndicesList << i;
5560     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5561     aMarkerScaleValuesList  << QString::number( i );
5562   }
5563   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5564   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5565
5566   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5567   //setPreferenceProperty( elemGroup, "columns", 2 );
5568
5569   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5570   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5571   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5572   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5573   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5574   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5575   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5576   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5577   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5578
5579
5580   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5581   setPreferenceProperty( grpGroup, "columns", 2 );
5582
5583   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5584   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5585
5586   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5587                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5588   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5589                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5590   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5591                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5592   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5593                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5594   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5595                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5596   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5597                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5598   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5599                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5600
5601   setPreferenceProperty( size0d, "min", 1 );
5602   setPreferenceProperty( size0d, "max", 10 );
5603
5604  // setPreferenceProperty( ballSize, "min", 1 );
5605  // setPreferenceProperty( ballSize, "max", 10 );
5606
5607   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5608   setPreferenceProperty( ballDiameter, "max", 1e9 );
5609   setPreferenceProperty( ballDiameter, "step", 0.1 );
5610
5611   setPreferenceProperty( ballScale, "min", 1e-2 );
5612   setPreferenceProperty( ballScale, "max", 1e7 );
5613   setPreferenceProperty( ballScale, "step", 0.5 );
5614
5615   setPreferenceProperty( elemW, "min", 1 );
5616   setPreferenceProperty( elemW, "max", 5 );
5617
5618   setPreferenceProperty( outW, "min", 1 );
5619   setPreferenceProperty( outW, "max", 5 );
5620
5621   setPreferenceProperty( shrink, "min", 0 );
5622   setPreferenceProperty( shrink, "max", 100 );
5623
5624   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5625   setPreferenceProperty( numGroup, "columns", 2 );
5626
5627   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5628   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5629
5630   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5631   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5632
5633   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5634   setPreferenceProperty( orientGroup, "columns", 1 );
5635
5636   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5637   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5638
5639   setPreferenceProperty( orientScale, "min", 0.05 );
5640   setPreferenceProperty( orientScale, "max", 0.5 );
5641   setPreferenceProperty( orientScale, "step", 0.05 );
5642
5643   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5644
5645   // Selection tab ------------------------------------------------------------------------
5646   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5647
5648   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5649   setPreferenceProperty( selGroup, "columns", 2 );
5650
5651   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5652   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5653
5654   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5655   setPreferenceProperty( preGroup, "columns", 2 );
5656
5657   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5658
5659   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5660   setPreferenceProperty( precSelGroup, "columns", 2 );
5661
5662   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5663   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5664   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5665
5666   int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5667   setPreferenceProperty( sinc, "min", 0 );
5668   setPreferenceProperty( sinc, "max", 5 );
5669
5670   // Scalar Bar tab ------------------------------------------------------------------------
5671   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5672   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5673   setPreferenceProperty( fontGr, "columns", 2 );
5674
5675   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5676   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5677
5678   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5679   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5680
5681   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5682   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5683
5684   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5685   setPreferenceProperty( numcol, "min", 2 );
5686   setPreferenceProperty( numcol, "max", 256 );
5687
5688   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5689   setPreferenceProperty( numlab, "min", 2 );
5690   setPreferenceProperty( numlab, "max", 65 );
5691
5692   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5693   setPreferenceProperty( orientGr, "columns", 2 );
5694   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5695   QStringList orients;
5696   orients.append( tr( "SMESH_VERTICAL" ) );
5697   orients.append( tr( "SMESH_HORIZONTAL" ) );
5698   indices.clear(); indices.append( 0 ); indices.append( 1 );
5699   setPreferenceProperty( orient, "strings", orients );
5700   setPreferenceProperty( orient, "indexes", indices );
5701
5702   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5703   setPreferenceProperty( posVSizeGr, "columns", 2 );
5704   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5705   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5706   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5707   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5708   setPreferenceProperty( xv, "step", 0.1 );
5709   setPreferenceProperty( xv, "min", 0.0 );
5710   setPreferenceProperty( xv, "max", 1.0 );
5711   setPreferenceProperty( yv, "step", 0.1 );
5712   setPreferenceProperty( yv, "min", 0.0 );
5713   setPreferenceProperty( yv, "max", 1.0 );
5714   setPreferenceProperty( wv, "step", 0.1 );
5715   setPreferenceProperty( wv, "min", 0.0 );
5716   setPreferenceProperty( wv, "max", 1.0 );
5717   setPreferenceProperty( hv, "min", 0.0 );
5718   setPreferenceProperty( hv, "max", 1.0 );
5719   setPreferenceProperty( hv, "step", 0.1 );
5720
5721   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5722   setPreferenceProperty( posHSizeGr, "columns", 2 );
5723   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5724   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5725   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5726   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5727   setPreferenceProperty( xv, "min", 0.0 );
5728   setPreferenceProperty( xv, "max", 1.0 );
5729   setPreferenceProperty( xv, "step", 0.1 );
5730   setPreferenceProperty( xh, "min", 0.0 );
5731   setPreferenceProperty( xh, "max", 1.0 );
5732   setPreferenceProperty( xh, "step", 0.1 );
5733   setPreferenceProperty( yh, "min", 0.0 );
5734   setPreferenceProperty( yh, "max", 1.0 );
5735   setPreferenceProperty( yh, "step", 0.1 );
5736   setPreferenceProperty( wh, "min", 0.0 );
5737   setPreferenceProperty( wh, "max", 1.0 );
5738   setPreferenceProperty( wh, "step", 0.1 );
5739   setPreferenceProperty( hh, "min", 0.0 );
5740   setPreferenceProperty( hh, "max", 1.0 );
5741   setPreferenceProperty( hh, "step", 0.1 );
5742
5743   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5744   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5745   setPreferenceProperty( distributionGr, "columns", 3 );
5746   QStringList types;
5747   types.append( tr( "SMESH_MONOCOLOR" ) );
5748   types.append( tr( "SMESH_MULTICOLOR" ) );
5749   indices.clear(); indices.append( 0 ); indices.append( 1 );
5750   setPreferenceProperty( coloringType, "strings", types );
5751   setPreferenceProperty( coloringType, "indexes", indices );
5752   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5753
5754 }
5755
5756 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5757 {
5758   if ( sect=="SMESH" ) {
5759     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5760     float aTol = 1.00000009999999;
5761     std::string aWarning;
5762     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5763
5764     if ( name ==  "selection_object_color" ||
5765          name == "selection_element_color" ||
5766          name ==         "highlight_color" ||
5767          name == "selection_precision_node"    ||
5768          name == "selection_precision_element" ||
5769          name == "selection_precision_object"  ||
5770          name == "selection_increment")
5771     {
5772       SMESH::UpdateSelectionProp( this );
5773     }
5774     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5775     {
5776       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5777       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5778       if ( sbX1+sbW > aTol ) {
5779         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5780         sbX1 = 0.01;
5781         sbW  = 0.08;
5782         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5783         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5784       }
5785     }
5786     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5787     {
5788       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5789       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5790       if ( sbY1 + sbH > aTol ) {
5791         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5792         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5793         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5794       }
5795     }
5796     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5797     {
5798       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5799       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5800       if ( sbX1 + sbW > aTol ) {
5801         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5802         sbX1=0.1;
5803         sbW =0.08;
5804         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5805         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5806       }
5807     }
5808     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5809     {
5810       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5811       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5812       if ( sbY1 + sbH > aTol ) {
5813         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5814         sbY1=0.01;
5815         sbH =0.08;
5816         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5817         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5818       }
5819     }
5820     else if ( name == "segmentation" )
5821     {
5822       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5823       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5824     }
5825     else if ( name == "nb_segments_per_edge" )
5826     {
5827       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5828       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5829     }
5830     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5831     {
5832       QString val = aResourceMgr->stringValue( "SMESH", name );
5833       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5834     }
5835     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5836     {
5837       SMESH::UpdateFontProp( this );
5838     }
5839     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5840     {
5841       SMESH::UpdateFontProp( this );
5842     }
5843
5844     if ( aWarning.size() != 0 ) {
5845       aWarning += "The default values are applied instead.";
5846       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5847                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5848                                QObject::tr(aWarning.c_str()));
5849     }
5850   }
5851 }
5852
5853 //================================================================================
5854 /*!
5855  * \brief Update something in accordance with update flags
5856   * \param theFlags - update flags
5857 *
5858 * Update viewer or/and object browser etc. in accordance with update flags ( see
5859 * LightApp_UpdateFlags enumeration ).
5860 */
5861 //================================================================================
5862 void SMESHGUI::update( const int flags )
5863 {
5864   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5865     SMESH::UpdateView();
5866   else
5867     SalomeApp_Module::update( flags );
5868 }
5869
5870 //================================================================================
5871 /*!
5872  * \brief Set default selection mode
5873 *
5874 * SLOT called when operation committed. Sets default selection mode
5875 */
5876 //================================================================================
5877 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5878 {
5879   SVTK_ViewWindow* vtkWnd =
5880     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5881   if ( vtkWnd )
5882     vtkWnd->SetSelectionMode( ActorSelection );
5883 }
5884
5885 //================================================================================
5886 /*!
5887  * \brief Set default selection mode
5888 *
5889 * SLOT called when operation aborted. Sets default selection mode
5890 */
5891 //================================================================================
5892 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5893 {
5894   SVTK_ViewWindow* vtkWnd =
5895     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5896   if ( vtkWnd )
5897     vtkWnd->SetSelectionMode( ActorSelection );
5898 }
5899
5900 //================================================================================
5901 /*!
5902  * \brief Creates operation with given identifier
5903   * \param id - identifier of operation to be started
5904   * \return Pointer on created operation or NULL if operation is not created
5905 *
5906 * Virtual method redefined from the base class creates operation with given id.
5907 * It is called called automatically from startOperation method of base class.
5908 */
5909 //================================================================================
5910 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5911 {
5912   LightApp_Operation* op = 0;
5913   // to do : create operation here
5914   switch( id )
5915   {
5916   case SMESHOp::OpSplitBiQuadratic:
5917     op = new SMESHGUI_SplitBiQuadOp();
5918     break;
5919   case SMESHOp::OpConvertMeshToQuadratic:
5920     op = new SMESHGUI_ConvToQuadOp();
5921     break;
5922   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5923     op = new SMESHGUI_Make2DFrom3DOp();
5924     break;
5925   case SMESHOp::OpReorientFaces:
5926     op = new SMESHGUI_ReorientFacesOp();
5927     break;
5928   case SMESHOp::OpCreateMesh:
5929     op = new SMESHGUI_MeshOp( true, true );
5930     break;
5931   case SMESHOp::OpCreateSubMesh:
5932     op = new SMESHGUI_MeshOp( true, false );
5933     break;
5934   case SMESHOp::OpEditMeshOrSubMesh:
5935   case SMESHOp::OpEditMesh:
5936   case SMESHOp::OpEditSubMesh:
5937     op = new SMESHGUI_MeshOp( false );
5938     break;
5939   case SMESHOp::OpCompute:
5940   case SMESHOp::OpComputeSubMesh:
5941     op = new SMESHGUI_ComputeOp();
5942     break;
5943   case SMESHOp::OpShowErrors:
5944     op = new SMESHGUI_ShowErrorsOp();
5945     break;
5946   case SMESHOp::OpPreCompute:
5947     op = new SMESHGUI_PrecomputeOp();
5948     break;
5949   case SMESHOp::OpEvaluate:
5950     op = new SMESHGUI_EvaluateOp();
5951     break;
5952   case SMESHOp::OpMeshOrder:
5953     op = new SMESHGUI_MeshOrderOp();
5954     break;
5955   case SMESHOp::OpCreateGeometryGroup:
5956     op = new SMESHGUI_GroupOnShapeOp();
5957     break;
5958   case SMESHOp::OpFindElementByPoint:
5959     op = new SMESHGUI_FindElemByPointOp();
5960     break;
5961   case SMESHOp::OpMoveNode: // Make mesh pass through point
5962     op = new SMESHGUI_MakeNodeAtPointOp();
5963     break;
5964   case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5965     op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5966     break;
5967   default:
5968     break;
5969   }
5970
5971   if( !op )
5972     op = SalomeApp_Module::createOperation( id );
5973   return op;
5974 }
5975
5976 //================================================================================
5977 /*!
5978  * \brief Stops current operations and starts a given one
5979   * \param id - The id of the operation to start
5980  */
5981 //================================================================================
5982
5983 void SMESHGUI::switchToOperation(int id)
5984 {
5985   activeStudy()->abortAllOperations();
5986   startOperation( id );
5987 }
5988
5989 LightApp_Displayer* SMESHGUI::displayer()
5990 {
5991   if( !myDisplayer )
5992     myDisplayer = new SMESHGUI_Displayer( getApp() );
5993   return myDisplayer;
5994 }
5995
5996 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5997 {
5998   int aHue = -1;
5999   int aTolerance = 64;
6000   int anIterations = 0;
6001   int aPeriod = 5;
6002
6003   while( 1 )
6004   {
6005     anIterations++;
6006     if( anIterations % aPeriod == 0 )
6007     {
6008       aTolerance /= 2;
6009       if( aTolerance < 1 )
6010         break;
6011     }
6012
6013     aHue = (int)( 360.0 * rand() / RAND_MAX );
6014
6015     bool ok = true;
6016     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6017     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6018     for( ; it != itEnd; ++it )
6019     {
6020       SALOMEDS::Color anAutoColor = *it;
6021       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6022
6023       int h, s, v;
6024       aQColor.getHsv( &h, &s, &v );
6025       if( abs( h - aHue ) < aTolerance )
6026       {
6027         ok = false;
6028         break;
6029       }
6030     }
6031
6032     if( ok )
6033       break;
6034   }
6035
6036   QColor aColor;
6037   aColor.setHsv( aHue, 255, 255 );
6038
6039   SALOMEDS::Color aSColor;
6040   aSColor.R = aColor.redF();
6041   aSColor.G = aColor.greenF();
6042   aSColor.B = aColor.blueF();
6043
6044   return aSColor;
6045 }
6046
6047 const char* gSeparator = "_"; // character used to separate parameter names
6048 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6049 const char* gPathSep   = "|"; // character used to separate paths
6050
6051 /*!
6052  * \brief Store visual parameters
6053  *
6054  * This method is called just before the study document is saved.
6055  * Store visual parameters in AttributeParameter attribute(s)
6056  */
6057 void SMESHGUI::storeVisualParameters (int savePoint)
6058 {
6059   // localizing
6060   Kernel_Utils::Localizer loc;
6061
6062   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6063   if (!appStudy || !appStudy->studyDS())
6064     return;
6065   _PTR(Study) studyDS = appStudy->studyDS();
6066
6067   // componentName is used for encoding of entries when storing them in IParameters
6068   std::string componentName = myComponentSMESH->ComponentDataType();
6069   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6070   //if (!aSComponent) return;
6071
6072   // IParameters
6073   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6074                                                              componentName.c_str(),
6075                                                              savePoint);
6076   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6077
6078   // store custom markers
6079   if( !myMarkerMap.empty() )
6080   {
6081     VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6082     for( ; anIter != myMarkerMap.end(); anIter++ )
6083     {
6084       int anId = anIter->first;
6085       VTK::MarkerData aMarkerData = anIter->second;
6086       std::string aMarkerFileName = aMarkerData.first;
6087       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6088       if( aMarkerTexture.size() < 3 )
6089         continue; // should contain at least width, height and the first value
6090
6091       QString aPropertyName( "texture" );
6092       aPropertyName += gSeparator;
6093       aPropertyName += QString::number( anId );
6094
6095       QString aPropertyValue = aMarkerFileName.c_str();
6096       aPropertyValue += gPathSep;
6097
6098       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6099       ushort aWidth = *aTextureIter++;
6100       ushort aHeight = *aTextureIter++;
6101       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6102       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6103       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6104         aPropertyValue += QString::number( *aTextureIter );
6105
6106       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6107     }
6108   }
6109
6110   // viewers counters are used for storing view_numbers in IParameters
6111   int vtkViewers = 0;
6112
6113   // main cycle to store parameters of displayed objects
6114   QList<SUIT_ViewManager*> lst;
6115   QList<SUIT_ViewManager*>::Iterator it;
6116   getApp()->viewManagers(lst);
6117   for (it = lst.begin(); it != lst.end(); it++)
6118   {
6119     SUIT_ViewManager* vman = *it;
6120     QString vType = vman->getType();
6121
6122     // saving VTK actors properties
6123     if (vType == SVTK_Viewer::Type())
6124     {
6125       // store the clipping planes attached to the view manager
6126       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6127       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6128       if( anIter != myClippingPlaneInfoMap.end() )
6129         aClippingPlaneInfoList = anIter->second;
6130
6131       if( !aClippingPlaneInfoList.empty() ) {
6132         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6133         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6134         {
6135           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6136           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6137
6138           QString aPropertyName( "ClippingPlane" );
6139           aPropertyName += gSeparator;
6140           aPropertyName += QString::number( vtkViewers );
6141           aPropertyName += gSeparator;
6142           aPropertyName += QString::number( anId );
6143
6144           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6145           aPropertyValue += gDigitsSep;
6146           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6147           aPropertyValue += gDigitsSep;
6148           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6149             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6150             aPropertyValue += gDigitsSep;
6151             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6152             aPropertyValue += gDigitsSep;
6153             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6154             aPropertyValue += gDigitsSep;
6155             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6156             aPropertyValue += gDigitsSep;
6157             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6158             aPropertyValue += gDigitsSep;
6159             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6160             aPropertyValue += gDigitsSep;
6161             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6162           }
6163           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6164             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6165             aPropertyValue += gDigitsSep;
6166             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6167             aPropertyValue += gDigitsSep;
6168             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6169             aPropertyValue += gDigitsSep;
6170             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6171           }
6172
6173           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6174         }
6175       }
6176
6177       QVector<SUIT_ViewWindow*> views = vman->getViews();
6178       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6179       {
6180         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6181         {
6182           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6183           vtkActorCollection* allActors = aCopy.GetActors();
6184           allActors->InitTraversal();
6185           while (vtkActor* actor = allActors->GetNextActor())
6186           {
6187             if (actor->GetVisibility()) // store only visible actors
6188             {
6189               SMESH_Actor* aSmeshActor = 0;
6190               if (actor->IsA("SMESH_Actor"))
6191                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6192               if (aSmeshActor && aSmeshActor->hasIO())
6193               {
6194                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6195                 if (io->hasEntry())
6196                 {
6197                   // entry is "encoded" = it does NOT contain component address,
6198                   // since it is a subject to change on next component loading
6199                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6200
6201                   std::string param, vtkParam = vType.toLatin1().data();
6202                   vtkParam += gSeparator;
6203                   vtkParam += QString::number(vtkViewers).toLatin1().data();
6204                   vtkParam += gSeparator;
6205
6206                   // Visibility
6207                   param = vtkParam + "Visibility";
6208                   ip->setParameter(entry, param, "On");
6209
6210                   // Representation
6211                   param = vtkParam + "Representation";
6212                   ip->setParameter(entry, param, QString::number
6213                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6214
6215                   // IsShrunk
6216                   param = vtkParam + "IsShrunk";
6217                   ip->setParameter(entry, param, QString::number
6218                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6219
6220                   // Displayed entities
6221                   unsigned int aMode = aSmeshActor->GetEntityMode();
6222                   bool isE  = aMode & SMESH_Actor::eEdges;
6223                   bool isF  = aMode & SMESH_Actor::eFaces;
6224                   bool isV  = aMode & SMESH_Actor::eVolumes;
6225                   bool is0d = aMode & SMESH_Actor::e0DElements;
6226                   bool isB  = aMode & SMESH_Actor::eBallElem;
6227
6228                   QString modeStr ("e");
6229                   modeStr += gDigitsSep; modeStr += QString::number(isE);
6230                   modeStr += gDigitsSep; modeStr += "f";
6231                   modeStr += gDigitsSep; modeStr += QString::number(isF);
6232                   modeStr += gDigitsSep; modeStr += "v";
6233                   modeStr += gDigitsSep; modeStr += QString::number(isV);
6234                   modeStr += gDigitsSep; modeStr += "0d";
6235                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
6236                   modeStr += gDigitsSep; modeStr += "b";
6237                   modeStr += gDigitsSep; modeStr += QString::number(isB);
6238
6239                   param = vtkParam + "Entities";
6240                   ip->setParameter(entry, param, modeStr.toLatin1().data());
6241
6242                   // Colors
6243                   double r, g, b;
6244                   int delta;
6245
6246                   aSmeshActor->GetSufaceColor(r, g, b, delta);
6247                   QStringList colorStr;
6248                   colorStr << "surface";
6249                   colorStr << QString::number(r);
6250                   colorStr << QString::number(g);
6251                   colorStr << QString::number(b);
6252
6253                   colorStr << "backsurface";
6254                   colorStr << QString::number(delta);
6255
6256                   aSmeshActor->GetVolumeColor(r, g, b, delta);
6257                   colorStr << "volume";
6258                   colorStr << QString::number(r);
6259                   colorStr << QString::number(g);
6260                   colorStr << QString::number(b);
6261                   colorStr << QString::number(delta);
6262
6263                   aSmeshActor->GetEdgeColor(r, g, b);
6264                   colorStr << "edge";
6265                   colorStr << QString::number(r);
6266                   colorStr << QString::number(g);
6267                   colorStr << QString::number(b);
6268
6269                   aSmeshActor->GetNodeColor(r, g, b);
6270                   colorStr << "node";
6271                   colorStr << QString::number(r);
6272                   colorStr << QString::number(g);
6273                   colorStr << QString::number(b);
6274
6275                   aSmeshActor->GetOutlineColor(r, g, b);
6276                   colorStr << "outline";
6277                   colorStr << QString::number(r);
6278                   colorStr << QString::number(g);
6279                   colorStr << QString::number(b);
6280
6281                   aSmeshActor->Get0DColor(r, g, b);
6282                   colorStr << "elem0d";
6283                   colorStr << QString::number(r);
6284                   colorStr << QString::number(g);
6285                   colorStr << QString::number(b);
6286
6287                   aSmeshActor->GetBallColor(r, g, b);
6288                   colorStr << "ball";
6289                   colorStr << QString::number(r);
6290                   colorStr << QString::number(g);
6291                   colorStr << QString::number(b);
6292
6293                   aSmeshActor->GetFacesOrientationColor(r, g, b);
6294                   colorStr << "orientation";
6295                   colorStr << QString::number(r);
6296                   colorStr << QString::number(g);
6297                   colorStr << QString::number(b);
6298
6299                   param = vtkParam + "Colors";
6300                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6301
6302                   // Sizes
6303                   QStringList sizeStr;
6304                   sizeStr << "line";
6305                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6306                   sizeStr << "outline";
6307                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6308                   sizeStr << "elem0d";
6309                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6310                   sizeStr << "ball";
6311                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6312                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6313                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6314                   sizeStr << "shrink";
6315                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6316                   sizeStr << "orientation";
6317                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6318                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6319
6320                   param = vtkParam + "Sizes";
6321                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6322
6323                   // Point marker
6324                   QString markerStr;
6325
6326                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6327                   if( aMarkerType == VTK::MT_USER ) {
6328                     markerStr += "custom";
6329                     markerStr += gDigitsSep;
6330                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6331                   }
6332                   else {
6333                     markerStr += "std";
6334                     markerStr += gDigitsSep;
6335                     markerStr += QString::number( (int)aMarkerType );
6336                     markerStr += gDigitsSep;
6337                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6338                   }
6339
6340                   param = vtkParam + "PointMarker";
6341                   ip->setParameter(entry, param, markerStr.toLatin1().data());
6342
6343                   // Opacity
6344                   param = vtkParam + "Opacity";
6345                   ip->setParameter(entry, param,
6346                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6347
6348                   // Clipping
6349                   param = vtkParam + "ClippingPlane";
6350                   int aPlaneId = 0;
6351                   if( !aClippingPlaneInfoList.empty() ) {
6352                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6353                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6354                     {
6355                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6356                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6357                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
6358                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6359                         if( aSmeshActor == *anIter2 ) {
6360                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6361                                             QString::number( anId ).toLatin1().constData() );
6362                           break;
6363                         }
6364                       }
6365                     }
6366                   }
6367                   if( aPlaneId == 0 )
6368                     ip->setParameter( entry, param, "Off" );
6369                 } // if (io->hasEntry())
6370               } // SMESH_Actor && hasIO
6371             } // isVisible
6372           } // while.. actors traversal
6373         } // if (vtkView)
6374       } // for (views)
6375       vtkViewers++;
6376     } // if (SVTK view model)
6377   } // for (viewManagers)
6378 }
6379
6380 // data structures for clipping planes processing
6381 typedef struct {
6382   int Id;
6383   int Mode;
6384   bool isOpenGLClipping;
6385   vtkIdType RelativeOrientation;
6386   double Distance;
6387   double Angle[2];
6388   int AbsoluteOrientation;
6389   double X, Y, Z, Dx, Dy, Dz;
6390 } TPlaneData;
6391 typedef std::list<TPlaneData>         TPlaneDataList;
6392 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6393
6394 typedef std::list<vtkActor*>          TActorList;
6395 typedef struct {
6396   int PlaneId;
6397   TActorList ActorList;
6398   SUIT_ViewManager* ViewManager;
6399 } TPlaneInfo;
6400 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6401 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6402
6403 /*!
6404  * \brief Restore visual parameters
6405  *
6406  * This method is called after the study document is opened.
6407  * Restore visual parameters from AttributeParameter attribute(s)
6408  */
6409 void SMESHGUI::restoreVisualParameters (int savePoint)
6410 {
6411   // localizing
6412   Kernel_Utils::Localizer loc;
6413
6414   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6415   if (!appStudy || !appStudy->studyDS())
6416     return;
6417   _PTR(Study) studyDS = appStudy->studyDS();
6418
6419   // componentName is used for encoding of entries when storing them in IParameters
6420   std::string componentName = myComponentSMESH->ComponentDataType();
6421
6422   // IParameters
6423   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6424                                                              componentName.c_str(),
6425                                                              savePoint);
6426   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6427
6428   // restore custom markers and map of clipping planes
6429   TPlaneDataMap aPlaneDataMap;
6430
6431   std::vector<std::string> properties = ip->getProperties();
6432   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6433   {
6434     std::string property = *propIt;
6435     QString aPropertyName( property.c_str() );
6436     QString aPropertyValue( ip->getProperty( property ).c_str() );
6437
6438     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6439     if( aPropertyNameList.isEmpty() )
6440       continue;
6441
6442     QString aPropertyType = aPropertyNameList[0];
6443     if( aPropertyType == "texture" )
6444     {
6445       if( aPropertyNameList.size() != 2 )
6446         continue;
6447
6448       bool ok = false;
6449       int anId = aPropertyNameList[1].toInt( &ok );
6450       if( !ok || anId < 1 )
6451         continue;
6452
6453       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6454       if( aPropertyValueList.size() != 2 )
6455         continue;
6456
6457       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6458       QString aMarkerTextureString = aPropertyValueList[1];
6459       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6460       if( aMarkerTextureStringList.size() != 3 )
6461         continue;
6462
6463       ok = false;
6464       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6465       if( !ok )
6466         continue;
6467
6468       ok = false;
6469       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6470       if( !ok )
6471         continue;
6472
6473       VTK::MarkerTexture aMarkerTexture;
6474       aMarkerTexture.push_back( aWidth );
6475       aMarkerTexture.push_back( aHeight );
6476
6477       QString aMarkerTextureData = aMarkerTextureStringList[2];
6478       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6479       {
6480         QChar aChar = aMarkerTextureData.at( i );
6481         if( aChar.isDigit() )
6482           aMarkerTexture.push_back( aChar.digitValue() );
6483       }
6484
6485       myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6486     }
6487     else if( aPropertyType == "ClippingPlane" )
6488     {
6489       if( aPropertyNameList.size() != 3 )
6490         continue;
6491
6492       bool ok = false;
6493       int aViewId = aPropertyNameList[1].toInt( &ok );
6494       if( !ok || aViewId < 0 )
6495         continue;
6496
6497       ok = false;
6498       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6499       if( !ok || aClippingPlaneId < 0 )
6500         continue;
6501
6502       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6503       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6504         continue;
6505
6506       TPlaneData aPlaneData;
6507       aPlaneData.AbsoluteOrientation = false;
6508       aPlaneData.RelativeOrientation = 0;
6509       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6510       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6511       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6512
6513       aPlaneData.Id = aClippingPlaneId;
6514
6515       ok = false;
6516       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6517       if( !ok )
6518         continue;
6519
6520       ok = false;
6521       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6522       if( !ok )
6523         continue;
6524
6525       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6526       {
6527         ok = false;
6528         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6529         if( !ok )
6530           continue;
6531
6532         ok = false;
6533         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6534         if( !ok )
6535           continue;
6536
6537         ok = false;
6538         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6539         if( !ok )
6540           continue;
6541
6542         ok = false;
6543         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6544         if( !ok )
6545           continue;
6546
6547         ok = false;
6548         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6549         if( !ok )
6550           continue;
6551
6552         ok = false;
6553         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6554         if( !ok )
6555           continue;
6556
6557         ok = false;
6558         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6559         if( !ok )
6560           continue;
6561       }
6562       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6563         ok = false;
6564         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6565         if( !ok )
6566           continue;
6567
6568         ok = false;
6569         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6570         if( !ok )
6571           continue;
6572
6573         ok = false;
6574         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6575         if( !ok )
6576           continue;
6577
6578         ok = false;
6579         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6580         if( !ok )
6581           continue;
6582       }
6583
6584       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6585       aPlaneDataList.push_back( aPlaneData );
6586     }
6587   }
6588
6589   TPlaneInfoMap aPlaneInfoMap;
6590
6591   std::vector<std::string> entries = ip->getEntries();
6592
6593   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6594   {
6595     // entry is a normal entry - it should be "decoded" (setting base address of component)
6596     QString entry (ip->decodeEntry(*entIt).c_str());
6597
6598     // Check that the entry corresponds to a real object in the Study
6599     // as the object may be deleted or modified after the visual state is saved.
6600     _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6601     if (!so) continue; //Skip the not existent entry
6602
6603     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6604     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6605
6606     std::vector<std::string>::iterator namesIt = paramNames.begin();
6607     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6608
6609     // actors are stored in a map after displaying of them for
6610     // quicker access in the future: map < viewID to actor >
6611     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6612
6613     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6614     {
6615       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6616       // '_' is used as separator and should not be used in viewer type or parameter names.
6617       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6618       if (lst.size() != 3)
6619         continue;
6620
6621       QString viewerTypStr = lst[0];
6622       QString viewIndexStr = lst[1];
6623       QString paramNameStr = lst[2];
6624
6625       bool ok;
6626       int viewIndex = viewIndexStr.toUInt(&ok);
6627       if (!ok) // bad conversion of view index to integer
6628         continue;
6629
6630       // viewers
6631       if (viewerTypStr == SVTK_Viewer::Type())
6632       {
6633         SMESH_Actor* aSmeshActor = 0;
6634         if (vtkActors.IsBound(viewIndex))
6635           aSmeshActor = vtkActors.Find(viewIndex);
6636
6637         QList<SUIT_ViewManager*> lst;
6638         getApp()->viewManagers(viewerTypStr, lst);
6639
6640         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6641         SUIT_ViewManager* vman = NULL;
6642         if (viewIndex >= 0 && viewIndex < lst.count())
6643           vman = lst.at(viewIndex);
6644
6645         if (paramNameStr == "Visibility")
6646         {
6647           if (!aSmeshActor && displayer() && vman)
6648           {
6649             SUIT_ViewModel* vmodel = vman->getViewModel();
6650             // SVTK view model can be casted to SALOME_View
6651             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6652
6653             // store displayed actor in a temporary map for quicker
6654             // access later when restoring other parameters
6655             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6656             vtkRenderer* Renderer = vtkView->getRenderer();
6657             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6658             vtkActorCollection* theActors = aCopy.GetActors();
6659             theActors->InitTraversal();
6660             bool isFound = false;
6661             vtkActor *ac = theActors->GetNextActor();
6662             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6663               if (ac->IsA("SMESH_Actor")) {
6664                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6665                 if (aGeomAc->hasIO()) {
6666                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6667                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6668                     isFound = true;
6669                     vtkActors.Bind(viewIndex, aGeomAc);
6670                   }
6671                 }
6672               }
6673             }
6674           }
6675         } // if (paramNameStr == "Visibility")
6676         else
6677         {
6678           // the rest properties "work" with SMESH_Actor
6679           if (aSmeshActor)
6680           {
6681             QString val ((*valuesIt).c_str());
6682
6683             // Representation
6684             if (paramNameStr == "Representation") {
6685               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6686             }
6687             // IsShrunk
6688             else if (paramNameStr == "IsShrunk") {
6689               if (val.toInt()) {
6690                 if (!aSmeshActor->IsShrunk())
6691                   aSmeshActor->SetShrink();
6692               }
6693               else {
6694                 if (aSmeshActor->IsShrunk())
6695                   aSmeshActor->UnShrink();
6696               }
6697             }
6698             // Displayed entities
6699             else if (paramNameStr == "Entities") {
6700               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6701               int aEntityMode = SMESH_Actor::eAllEntity;
6702               for ( int i = 0; i < mode.count(); i+=2 ) {
6703                 if ( i < mode.count()-1 ) {
6704                   QString type = mode[i];
6705                   bool val = mode[i+1].toInt();
6706                   if      ( type == "e" && !val )
6707                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6708                   else if ( type == "f" && !val )
6709                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6710                   else if ( type == "v" && !val )
6711                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6712                   else if ( type == "0d" && !val )
6713                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6714                   else if ( type == "b" && !val )
6715                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6716                 }
6717               }
6718               aSmeshActor->SetEntityMode( aEntityMode );
6719             }
6720             // Colors
6721             else if (paramNameStr == "Colors") {
6722               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6723               QColor nodeColor;
6724               QColor edgeColor;
6725               QColor faceColor;
6726               QColor volumeColor;
6727               QColor elem0dColor;
6728               QColor ballColor;
6729               QColor outlineColor;
6730               QColor orientationColor;
6731               int deltaF;
6732               int deltaV;
6733               QColor c;
6734               double r, g, b;
6735               bool bOk;
6736               // below lines are required to get default values for delta coefficients
6737               // of backface color for faces and color of reversed volumes
6738               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6739               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6740               for ( int i = 0; i < colors.count(); i++ ) {
6741                 QString type = colors[i];
6742                 if ( type == "surface" ) {
6743                   // face color is set by 3 values r:g:b, where
6744                   // - r,g,b - is rgb color components
6745                   if ( i+1 >= colors.count() ) break;                  // format error
6746                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6747                   if ( i+2 >= colors.count() ) break;                  // format error
6748                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6749                   if ( i+3 >= colors.count() ) break;                  // format error
6750                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6751                   faceColor.setRgbF( r, g, b );
6752                   i += 3;
6753                 }
6754                 else if ( type == "backsurface" ) {
6755                   // backface color can be defined in several ways
6756                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6757                   // - in latest versions, it is set as delta coefficient
6758                   bool rgbOk = false, deltaOk;
6759                   if ( i+1 >= colors.count() ) break;                  // format error
6760                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6761                   int delta = colors[i+1].toInt( &deltaOk );
6762                   i++;                                 // shift index
6763                   if ( i+1 < colors.count() )          // index is shifted to 1
6764                     g = colors[i+1].toDouble( &rgbOk );
6765                   if ( rgbOk ) i++;                    // shift index
6766                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6767                     b = colors[i+1].toDouble( &rgbOk );
6768                   if ( rgbOk ) i++;
6769                   // - as currently there's no way to set directly backsurface color as it was before,
6770                   // we ignore old dump where r,g,b triple was set
6771                   // - also we check that delta parameter is set properly
6772                   if ( !rgbOk && deltaOk )
6773                     deltaF = delta;
6774                 }
6775                 else if ( type == "volume" ) {
6776                   // volume color is set by 4 values r:g:b:delta, where
6777                   // - r,g,b - is a normal volume rgb color components
6778                   // - delta - is a reversed volume color delta coefficient
6779                   if ( i+1 >= colors.count() ) break;                  // format error
6780                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6781                   if ( i+2 >= colors.count() ) break;                  // format error
6782                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6783                   if ( i+3 >= colors.count() ) break;                  // format error
6784                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6785                   if ( i+4 >= colors.count() ) break;                  // format error
6786                   int delta = colors[i+4].toInt( &bOk );
6787                   if ( !bOk ) break;                                   // format error
6788                   volumeColor.setRgbF( r, g, b );
6789                   deltaV = delta;
6790                   i += 4;
6791                 }
6792                 else if ( type == "edge" ) {
6793                   // edge color is set by 3 values r:g:b, where
6794                   // - r,g,b - is rgb color components
6795                   if ( i+1 >= colors.count() ) break;                  // format error
6796                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6797                   if ( i+2 >= colors.count() ) break;                  // format error
6798                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6799                   if ( i+3 >= colors.count() ) break;                  // format error
6800                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6801                   edgeColor.setRgbF( r, g, b );
6802                   i += 3;
6803                 }
6804                 else if ( type == "node" ) {
6805                   // node color is set by 3 values r:g:b, where
6806                   // - r,g,b - is rgb color components
6807                   if ( i+1 >= colors.count() ) break;                  // format error
6808                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6809                   if ( i+2 >= colors.count() ) break;                  // format error
6810                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6811                   if ( i+3 >= colors.count() ) break;                  // format error
6812                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6813                   nodeColor.setRgbF( r, g, b );
6814                   i += 3;
6815                 }
6816                 else if ( type == "elem0d" ) {
6817                   // 0d element color is set by 3 values r:g:b, where
6818                   // - r,g,b - is rgb color components
6819                   if ( i+1 >= colors.count() ) break;                  // format error
6820                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6821                   if ( i+2 >= colors.count() ) break;                  // format error
6822                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6823                   if ( i+3 >= colors.count() ) break;                  // format error
6824                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6825                   elem0dColor.setRgbF( r, g, b );
6826                   i += 3;
6827                 }
6828                 else if ( type == "ball" ) {
6829                   // ball color is set by 3 values r:g:b, where
6830                   // - r,g,b - is rgb color components
6831                   if ( i+1 >= colors.count() ) break;                  // format error
6832                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6833                   if ( i+2 >= colors.count() ) break;                  // format error
6834                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6835                   if ( i+3 >= colors.count() ) break;                  // format error
6836                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6837                   ballColor.setRgbF( r, g, b );
6838                   i += 3;
6839                 }
6840                 else if ( type == "outline" ) {
6841                   // outline color is set by 3 values r:g:b, where
6842                   // - r,g,b - is rgb color components
6843                   if ( i+1 >= colors.count() ) break;                  // format error
6844                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6845                   if ( i+2 >= colors.count() ) break;                  // format error
6846                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6847                   if ( i+3 >= colors.count() ) break;                  // format error
6848                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6849                   outlineColor.setRgbF( r, g, b );
6850                   i += 3;
6851                 }
6852                 else if ( type == "orientation" ) {
6853                   // orientation color is set by 3 values r:g:b, where
6854                   // - r,g,b - is rgb color components
6855                   if ( i+1 >= colors.count() ) break;                  // format error
6856                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6857                   if ( i+2 >= colors.count() ) break;                  // format error
6858                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6859                   if ( i+3 >= colors.count() ) break;                  // format error
6860                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6861                   orientationColor.setRgbF( r, g, b );
6862                   i += 3;
6863                 }
6864               }
6865               // node color
6866               if ( nodeColor.isValid() )
6867                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6868               // edge color
6869               if ( edgeColor.isValid() )
6870                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6871               // face color
6872               if ( faceColor.isValid() )
6873                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6874               // volume color
6875               if ( volumeColor.isValid() )
6876                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6877               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6878                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6879               // 0d element color
6880               if ( elem0dColor.isValid() )
6881                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6882               // ball color
6883               if ( ballColor.isValid() )
6884                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6885               // outline color
6886               if ( outlineColor.isValid() )
6887                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6888               // orientation color
6889               if ( orientationColor.isValid() )
6890                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6891             }
6892             // Sizes
6893             else if (paramNameStr == "Sizes") {
6894               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6895               bool bOk;
6896               int lineWidth = -1;
6897               int outlineWidth = -1;
6898               int elem0dSize = -1;
6899               //int ballSize = -1;
6900               double ballDiameter = -1.0;
6901               double ballScale = -1.0;
6902               double shrinkSize = -1;
6903               double orientationSize = -1;
6904               bool orientation3d = false;
6905               for ( int i = 0; i < sizes.count(); i++ ) {
6906                 QString type = sizes[i];
6907                 if ( type == "line" ) {
6908                   // line (wireframe) width is given as single integer value
6909                   if ( i+1 >= sizes.count() ) break;                    // format error
6910                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6911                   lineWidth = v;
6912                   i++;
6913                 }
6914                 if ( type == "outline" ) {
6915                   // outline width is given as single integer value
6916                   if ( i+1 >= sizes.count() ) break;                    // format error
6917                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6918                   outlineWidth = v;
6919                   i++;
6920                 }
6921                 else if ( type == "elem0d" ) {
6922                   // 0d element size is given as single integer value
6923                   if ( i+1 >= sizes.count() ) break;                    // format error
6924                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6925                   elem0dSize = v;
6926                   i++;
6927                 }
6928                 else if ( type == "ball" ) {
6929                   // balls are specified by two values: size:scale, where
6930                   // - size - is a integer value specifying size
6931                   // - scale - is a double value specifying scale factor
6932                   if ( i+1 >= sizes.count() ) break;                       // format error
6933                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6934                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6935                   if ( i+2 >= sizes.count() ) break;                       // format error
6936                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6937                   //ballSize = v1;
6938                   ballDiameter = v1;
6939                   ballScale = v2;
6940                   i += 2;
6941                 }
6942                 else if ( type == "shrink" ) {
6943                   // shrink factor is given as single floating point value
6944                   if ( i+1 >= sizes.count() ) break;                          // format error
6945                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6946                   shrinkSize = v;
6947                   i++;
6948                 }
6949                 else if ( type == "orientation" ) {
6950                   // orientation vectors are specified by two values size:3d, where
6951                   // - size - is a floating point value specifying scale factor
6952                   // - 3d - is a boolean
6953                   if ( i+1 >= sizes.count() ) break;                          // format error
6954                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6955                   if ( i+2 >= sizes.count() ) break;                          // format error
6956                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6957                   orientationSize = v1;
6958                   orientation3d = (bool)v2;
6959                   i += 2;
6960                 }
6961               }
6962               // line (wireframe) width
6963               if ( lineWidth > 0 )
6964                 aSmeshActor->SetLineWidth( lineWidth );
6965               // outline width
6966               if ( outlineWidth > 0 )
6967                 aSmeshActor->SetOutlineWidth( outlineWidth );
6968               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6969                 aSmeshActor->SetOutlineWidth( lineWidth );
6970               // 0d element size
6971               if ( elem0dSize > 0 )
6972                 aSmeshActor->Set0DSize( elem0dSize );
6973               // ball size
6974               /*if ( ballSize > 0 )
6975                 aSmeshActor->SetBallSize( ballSize );*/
6976               // ball diameter
6977               if ( ballDiameter > 0 )
6978                 aSmeshActor->SetBallSize( ballDiameter );
6979               // ball scale
6980               if ( ballScale > 0.0 )
6981                 aSmeshActor->SetBallScale( ballScale );
6982               // shrink factor
6983               if ( shrinkSize > 0 )
6984                 aSmeshActor->SetShrinkFactor( shrinkSize );
6985               // orientation vectors
6986               if ( orientationSize > 0 ) {
6987                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6988                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6989               }
6990             }
6991             // Point marker
6992             else if (paramNameStr == "PointMarker") {
6993               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6994               if( data.count() >= 2 ) {
6995                 bool ok = false;
6996                 int aParam1 = data[1].toInt( &ok );
6997                 if( ok ) {
6998                   if( data[0] == "std" && data.count() == 3 ) {
6999                     int aParam2 = data[2].toInt( &ok );
7000                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7001                   }
7002                   else if( data[0] == "custom" ) {
7003                     VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7004                     if( markerIt != myMarkerMap.end() ) {
7005                       VTK::MarkerData aMarkerData = markerIt->second;
7006                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7007                     }
7008                   }
7009                 }
7010               }
7011             }
7012             // Opacity
7013             else if (paramNameStr == "Opacity") {
7014               aSmeshActor->SetOpacity(val.toFloat());
7015             }
7016             // Clipping
7017             else if (paramNameStr.startsWith("ClippingPlane")) {
7018               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7019               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7020               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7021               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7022               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7023               // new format - val looks like "Off" or "0" (plane id)
7024               // (note: in new format "Off" value is used only for consistency,
7025               //  so it is processed together with values in old format)
7026               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7027               if( anIsOldFormat ) {
7028                 if (paramNameStr == "ClippingPlane1" || val == "Off")
7029                   aSmeshActor->RemoveAllClippingPlanes();
7030                 if (val != "Off") {
7031                   QList<SUIT_ViewManager*> lst;
7032                   getApp()->viewManagers(viewerTypStr, lst);
7033                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7034                   if (viewIndex >= 0 && viewIndex < lst.count()) {
7035                     SUIT_ViewManager* vman = lst.at(viewIndex);
7036                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7037
7038                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7039
7040                     SMESH::TActorList anActorList;
7041                     anActorList.push_back( aSmeshActor );
7042                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7043                     aPlane->myViewWindow = vtkView;
7044                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7045                     aPlane->PlaneMode = aMode;
7046                     bool isOpenGLClipping = ( bool )vals[1].toInt();
7047                     aPlane->IsOpenGLClipping = isOpenGLClipping;
7048                     if ( aMode == SMESH::Absolute ) {
7049                       aPlane->myAbsoluteOrientation = vals[2].toInt();
7050                       aPlane->X = vals[3].toFloat();
7051                       aPlane->Y = vals[4].toFloat();
7052                       aPlane->Z = vals[5].toFloat();
7053                       aPlane->Dx = vals[6].toFloat();
7054                       aPlane->Dy = vals[7].toFloat();
7055                       aPlane->Dz = vals[8].toFloat();
7056                     }
7057                     else if ( aMode == SMESH::Relative ) {
7058                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7059                       aPlane->myDistance = vals[3].toFloat();
7060                       aPlane->myAngle[0] = vals[4].toFloat();
7061                       aPlane->myAngle[1] = vals[5].toFloat();
7062                     }
7063
7064                     if( aPlane ) {
7065                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7066                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7067                         aClippingPlaneInfo.Plane = aPlane;
7068                         aClippingPlaneInfo.ActorList = anActorList;
7069                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7070                       }
7071                     }
7072                   }
7073                 }
7074               }
7075               else {
7076                 bool ok = false;
7077                 int aPlaneId = val.toInt( &ok );
7078                 if( ok && aPlaneId >= 0 ) {
7079                   bool anIsDefinedPlane = false;
7080                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7081                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7082                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7083                     TPlaneInfo& aPlaneInfo = *anIter;
7084                     if( aPlaneInfo.PlaneId == aPlaneId ) {
7085                       aPlaneInfo.ActorList.push_back( aSmeshActor );
7086                       anIsDefinedPlane = true;
7087                       break;
7088                     }
7089                   }
7090                   if( !anIsDefinedPlane ) {
7091                     TPlaneInfo aPlaneInfo;
7092                     aPlaneInfo.PlaneId = aPlaneId;
7093                     aPlaneInfo.ActorList.push_back( aSmeshActor );
7094                     aPlaneInfo.ViewManager = vman;
7095
7096                     // to make the list sorted by plane id
7097                     anIter = aPlaneInfoList.begin();
7098                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7099                       const TPlaneInfo& aPlaneInfoRef = *anIter;
7100                       if( aPlaneInfoRef.PlaneId > aPlaneId )
7101                         break;
7102                     }
7103                     aPlaneInfoList.insert( anIter, aPlaneInfo );
7104                   }
7105                 }
7106               }
7107             }
7108           } // if (aSmeshActor)
7109         } // other parameters than Visibility
7110       }
7111     } // for names/parameters iterator
7112   } // for entries iterator
7113
7114   // take into account planes with empty list of actors referred to them
7115   QList<SUIT_ViewManager*> aVMList;
7116   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7117
7118   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7119   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7120     int aViewId = aPlaneDataIter->first;
7121     if( aViewId >= 0 && aViewId < aVMList.count() ) {
7122       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7123
7124       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7125
7126       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7127       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7128       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7129         const TPlaneData& aPlaneData = *anIter2;
7130         int aPlaneId = aPlaneData.Id;
7131
7132         bool anIsFound = false;
7133         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7134         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7135           const TPlaneInfo& aPlaneInfo = *anIter3;
7136           if( aPlaneInfo.PlaneId == aPlaneId ) {
7137             anIsFound = true;
7138             break;
7139           }
7140         }
7141
7142         if( !anIsFound ) {
7143           TPlaneInfo aPlaneInfo; // ActorList field is empty
7144           aPlaneInfo.PlaneId = aPlaneId;
7145           aPlaneInfo.ViewManager = aViewManager;
7146
7147           // to make the list sorted by plane id
7148           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7149           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7150             const TPlaneInfo& aPlaneInfoRef = *anIter4;
7151             if( aPlaneInfoRef.PlaneId > aPlaneId )
7152               break;
7153           }
7154           aPlaneInfoList.insert( anIter4, aPlaneInfo );
7155         }
7156       }
7157     }
7158   }
7159
7160   // add clipping planes to actors according to the restored parameters
7161   // and update the clipping plane map
7162   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7163   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7164     int aViewId = anIter1->first;
7165     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7166
7167     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7168     if( anIter2 == aPlaneDataMap.end() )
7169       continue;
7170     const TPlaneDataList& aPlaneDataList = anIter2->second;
7171
7172     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7173     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7174       const TPlaneInfo& aPlaneInfo = *anIter3;
7175       int aPlaneId = aPlaneInfo.PlaneId;
7176       const TActorList& anActorList = aPlaneInfo.ActorList;
7177       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7178       if( !aViewManager )
7179         continue;
7180
7181       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7182       if( !aViewWindow )
7183         continue;
7184
7185       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7186
7187       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7188       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7189         const TPlaneData& aPlaneData = *anIter4;
7190         if( aPlaneData.Id == aPlaneId ) {
7191           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7192           aPlane->myViewWindow = aViewWindow;
7193           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7194           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7195           if ( aPlane->PlaneMode == SMESH::Absolute ) {
7196             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7197             aPlane->X = aPlaneData.X;
7198             aPlane->Y = aPlaneData.Y;
7199             aPlane->Z = aPlaneData.Z;
7200             aPlane->Dx = aPlaneData.Dx;
7201             aPlane->Dy = aPlaneData.Dy;
7202             aPlane->Dz = aPlaneData.Dz;
7203           }
7204           else if ( aPlane->PlaneMode == SMESH::Relative ) {
7205             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7206             aPlane->myDistance = aPlaneData.Distance;
7207             aPlane->myAngle[0] = aPlaneData.Angle[0];
7208             aPlane->myAngle[1] = aPlaneData.Angle[1];
7209           }
7210           if( aPlane ) {
7211             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7212               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7213               aClippingPlaneInfo.Plane = aPlane;
7214               aClippingPlaneInfo.ActorList = anActorList;
7215               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7216             }
7217           }
7218           break;
7219         }
7220       }
7221
7222     }
7223   }
7224
7225
7226   // update all VTK views
7227   QList<SUIT_ViewManager*> lst;
7228   getApp()->viewManagers(lst);
7229   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7230     SUIT_ViewModel* vmodel = (*it)->getViewModel();
7231     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7232       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7233       // set OpenGL clipping planes
7234       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7235       vtkActorCollection* anAllActors = aCopy.GetActors();
7236       anAllActors->InitTraversal();
7237       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7238         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7239           anActor->SetOpenGLClippingPlane();
7240
7241       vtkView->getRenderer()->ResetCameraClippingRange();
7242       vtkView->Repaint();
7243     }
7244   }
7245 }
7246
7247 /*!
7248   \brief Adds preferences for dfont of VTK viewer
7249   \param label label
7250   \param pIf group identifier
7251   \param param parameter
7252   \return identifier of preferences
7253 */
7254 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7255 {
7256   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7257
7258   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7259
7260   QStringList fam;
7261   fam.append( tr( "SMESH_FONT_ARIAL" ) );
7262   fam.append( tr( "SMESH_FONT_COURIER" ) );
7263   fam.append( tr( "SMESH_FONT_TIMES" ) );
7264
7265   setPreferenceProperty( tfont, "fonts", fam );
7266
7267   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7268   if ( needSize ) f = f | QtxFontEdit::Size;
7269   setPreferenceProperty( tfont, "features", f );
7270
7271   return tfont;
7272 }
7273
7274 /*!
7275   \brief Actions after hypothesis edition
7276   Updates object browser after hypothesis edition
7277 */
7278 void SMESHGUI::onHypothesisEdit( int result )
7279 {
7280   if( result == 1 )
7281     SMESHGUI::Modified();
7282   updateObjBrowser( true );
7283 }
7284
7285 /*!
7286   \brief Actions after choosing menu of control modes
7287   Updates control mode actions according to current selection
7288 */
7289 void SMESHGUI::onUpdateControlActions()
7290 {
7291   SALOME_ListIO selected;
7292   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7293     aSel->selectedObjects( selected );
7294
7295   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7296   if ( selected.Extent() ) {
7297     if ( selected.First()->hasEntry() ) {
7298       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7299         aControl = anActor->GetControlMode();
7300         SALOME_ListIteratorOfListIO it(selected);
7301         for ( it.Next(); it.More(); it.Next() ) {
7302           Handle(SALOME_InteractiveObject) anIO = it.Value();
7303           if ( anIO->hasEntry() ) {
7304             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7305               if ( aControl != anActor->GetControlMode() ) {
7306                 aControl = SMESH_Actor::eNone;
7307                 break;
7308               }
7309             }
7310           }
7311         }
7312       }
7313     }
7314   }
7315
7316   int anAction = ActionToControl( aControl, true );
7317   if ( anAction)
7318     action( anAction )->setChecked( true );
7319   else {
7320     QMenu* send = (QMenu*)sender();
7321     QList<QAction*> actions = send->actions();
7322     for ( int i = 0; i < actions.size(); i++ )
7323       actions[i]->setChecked( false );
7324   }
7325 }
7326
7327
7328 /*!
7329   \brief Signal handler closing(SUIT_ViewWindow*) of a view
7330   \param pview view being closed
7331 */
7332 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7333 #ifndef DISABLE_PLOT2DVIEWER
7334   //Crear all Plot2d Viewers if need.
7335   SMESH::ClearPlot2Viewers(pview);
7336 #endif
7337   EmitSignalCloseView();
7338 }
7339
7340 void SMESHGUI::message( const QString& msg )
7341 {
7342   // dispatch message
7343   QStringList data = msg.split("/");
7344   if ( data.count() > 0 ) {
7345     if ( data.first() == "mesh_loading" ) {
7346       // get mesh entry
7347       QString entry = data.count() > 1 ? data[1] : QString();
7348       if ( entry.isEmpty() )
7349         return;
7350       // get study
7351       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7352       // get mesh name
7353       _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7354       QString name;
7355       if ( obj )
7356         name = SMESH::fromUtf8(obj->GetName());
7357       if ( name.isEmpty() )
7358         return;
7359
7360       if ( data.last() == "stop" )
7361         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7362       else
7363         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7364       QApplication::processEvents();
7365     }
7366   }
7367 }
7368
7369 /*!
7370   \brief Connects or disconnects signals about activating and cloning view on the module slots
7371   \param pview view which is connected/disconnected
7372 */
7373 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7374   if(!pview)
7375     return;
7376
7377   SUIT_ViewManager* viewMgr = pview->getViewManager();
7378   if ( viewMgr ) {
7379     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7380                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7381
7382     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7383              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7384   }
7385 }
7386
7387 /*!
7388   \brief Return \c true if object can be renamed
7389 */
7390 bool SMESHGUI::renameAllowed( const QString& entry) const {
7391   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7392   if( !anApp )
7393     return false;
7394
7395   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7396   if( !appStudy )
7397     return false;
7398
7399   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7400
7401   if(!obj)
7402     return false;
7403
7404   if(appStudy->isComponent(entry) || obj->isReference())
7405     return false;
7406
7407   // check type to prevent renaming of inappropriate objects
7408   int aType = SMESHGUI_Selection::type(qPrintable(entry));
7409   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7410       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7411       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7412       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7413       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7414     return true;
7415
7416   return false;
7417 }
7418
7419 /*!
7420   Rename object by entry.
7421   \param entry entry of the object
7422   \param name new name of the object
7423   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7424 */
7425 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7426
7427   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7428   if( !anApp )
7429     return false;
7430
7431   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7432
7433   if(!appStudy)
7434     return false;
7435
7436   _PTR(Study) aStudy = appStudy->studyDS();
7437
7438   if(!aStudy)
7439     return false;
7440
7441   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7442   if ( aLocked ) {
7443     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7444     return false;
7445   }
7446
7447
7448   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7449   _PTR(GenericAttribute) anAttr;
7450   _PTR(AttributeName) aName;
7451   if ( obj ) {
7452     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7453       aName = anAttr;
7454       // check type to prevent renaming of inappropriate objects
7455       int aType = SMESHGUI_Selection::type( qPrintable(entry));
7456       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7457           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7458           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7459           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7460           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7461         if ( !name.isEmpty() ) {
7462           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7463
7464           // update name of group object and its actor
7465           Handle(SALOME_InteractiveObject) IObject =
7466             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7467
7468           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7469           if( !aGroupObject->_is_nil() ) {
7470             aGroupObject->SetName( qUtf8Printable(name) );
7471             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7472               anActor->setName( qUtf8Printable(name) );
7473           }
7474           return true;
7475         }
7476       }
7477     }
7478   }
7479   return false;
7480 }
7481
7482 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7483 {
7484   static QList<QColor> colors;
7485
7486   if ( colors.isEmpty() ) {
7487
7488     for (int s = 0; s < 2 ; s++)
7489     {
7490       for (int v = 100; v >= 40; v = v - 20)
7491       {
7492         for (int h = 0; h < 359 ; h = h + 60)
7493         {
7494           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7495         }
7496       }
7497     }
7498   }
7499   static int currentColor = randomize( colors.size() );
7500
7501   SALOMEDS::Color color;
7502   color.R = (double)colors[currentColor].red()   / 255.0;
7503   color.G = (double)colors[currentColor].green() / 255.0;
7504   color.B = (double)colors[currentColor].blue()  / 255.0;
7505
7506   currentColor = (currentColor+1) % colors.count();
7507
7508   return color;
7509 }