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