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