src/SMESHGUI/SMESHGUI.cxx

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