src/SMESHGUI/SMESHGUI.cxx

   1 // Copyright (C) 2007-2011  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.
  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 //  SMESH includes
  31 #include "SMESHGUI.h"
  32 #include "SMESHGUI_AddMeshElementDlg.h"
  33 #include "SMESHGUI_AddQuadraticElementDlg.h"
  34 #include "SMESHGUI_BuildCompoundDlg.h"
  35 #include "SMESHGUI_ClippingDlg.h"
  36 #include "SMESHGUI_ComputeDlg.h"
  37 #include "SMESHGUI_ConvToQuadOp.h"
  38 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
  39 #include "SMESHGUI_DeleteGroupDlg.h"
  40 #include "SMESHGUI_Displayer.h"
  41 #include "SMESHGUI_MergeDlg.h"
  42 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
  43 #include "SMESHGUI_ExtrusionDlg.h"
  44 #include "SMESHGUI_FileInfoDlg.h"
  45 #include "SMESHGUI_FileValidator.h"
  46 #include "SMESHGUI_FilterDlg.h"
  47 #include "SMESHGUI_FilterLibraryDlg.h"
  48 #include "SMESHGUI_FindElemByPointDlg.h"
  49 #include "SMESHGUI_GroupDlg.h"
  50 #include "SMESHGUI_GroupOnShapeDlg.h"
  51 #include "SMESHGUI_GroupOpDlg.h"
  52 #include "SMESHGUI_Hypotheses.h"
  53 #include "SMESHGUI_Make2DFrom3DOp.h"
  54 #include "SMESHGUI_MakeNodeAtPointDlg.h"
  55 #include "SMESHGUI_Measurements.h"
  56 #include "SMESHGUI_MeshInfo.h"
  57 #include "SMESHGUI_MeshOp.h"
  58 #include "SMESHGUI_MeshOrderOp.h"
  59 #include "SMESHGUI_MeshPatternDlg.h"
  60 #include "SMESHGUI_MultiEditDlg.h"
  61 #include "SMESHGUI_NodesDlg.h"
  62 #include "SMESHGUI_Preferences_ColorDlg.h"
  63 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
  64 #include "SMESHGUI_RemoveElementsDlg.h"
  65 #include "SMESHGUI_RemoveNodesDlg.h"
  66 #include "SMESHGUI_RenumberingDlg.h"
  67 #include "SMESHGUI_RevolutionDlg.h"
  68 #include "SMESHGUI_RotationDlg.h"
  69 #include "SMESHGUI_Selection.h"
  70 #include "SMESHGUI_SewingDlg.h"
  71 #include "SMESHGUI_SingleEditDlg.h"
  72 #include "SMESHGUI_SmoothingDlg.h"
  73 #include "SMESHGUI_SymmetryDlg.h"
  74 #include "SMESHGUI_TranslationDlg.h"
  75 #include "SMESHGUI_ScaleDlg.h"
  76 #include "SMESHGUI_TransparencyDlg.h"
  77 #include "SMESHGUI_DuplicateNodesDlg.h"
  78 #include "SMESHGUI_CopyMeshDlg.h"
  79
  80 #include "SMESHGUI_Utils.h"
  81 #include "SMESHGUI_MeshUtils.h"
  82 #include "SMESHGUI_GroupUtils.h"
  83 #include "SMESHGUI_FilterUtils.h"
  84 #include "SMESHGUI_PatternUtils.h"
  85 #include "SMESHGUI_VTKUtils.h"
  86 #include "SMESHGUI_HypothesesUtils.h"
  87
  88 #include <SMESH_version.h>
  89
  90 #include <SMESH_Client.hxx>
  91 #include <SMESH_Actor.h>
  92 #include <SMESH_ScalarBarActor.h>
  93 #include <SMESH_ActorUtils.h>
  94 #include <SMESH_TypeFilter.hxx>
  95 #include "SMESH_ControlsDef.hxx"
  96
  97 // SALOME GUI includes
  98 #include <SalomeApp_Tools.h>
  99 #include <SalomeApp_Study.h>
 100 #include <SalomeApp_Application.h>
 101 #include <SalomeApp_CheckFileDlg.h>
 102
 103 #include <LightApp_DataOwner.h>
 104 #include <LightApp_Preferences.h>
 105 #include <LightApp_SelectionMgr.h>
 106 #include <LightApp_UpdateFlags.h>
 107 #include <LightApp_NameDlg.h>
 108
 109 #include <SVTK_ViewWindow.h>
 110 #include <SVTK_ViewModel.h>
 111 #include <SVTK_ViewManager.h>
 112
 113 #include <VTKViewer_Algorithm.h>
 114
 115 #include <SUIT_MessageBox.h>
 116 #include <SUIT_ResourceMgr.h>
 117 #include <SUIT_FileDlg.h>
 118 #include <SUIT_Desktop.h>
 119 #include <SUIT_OverrideCursor.h>
 120 #include <SUIT_Session.h>
 121
 122 #include <QtxPopupMgr.h>
 123 #include <QtxFontEdit.h>
 124
 125 #include <SALOME_ListIO.hxx>
 126 #include <SALOME_ListIteratorOfListIO.hxx>
 127
 128 #ifndef DISABLE_PLOT2DVIEWER
 129 #include <SPlot2d_ViewModel.h>
 130 #include <SPlot2d_Histogram.h>
 131 #endif
 132
 133 // IDL includes
 134 #include <SALOMEconfig.h>
 135 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
 136 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
 137 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
 138
 139 // Qt includes
 140 // #define       INCLUDE_MENUITEM_DEF // VSR commented ????????
 141 #include <QMenu>
 142 #include <QTextStream>
 143
 144 // BOOST includes
 145 #include <boost/shared_ptr.hpp>
 146
 147 // VTK includes
 148 #include <vtkCamera.h>
 149 #include <vtkRenderer.h>
 150 #include <vtkPlane.h>
 151 #include <vtkCallbackCommand.h>
 152 #include <vtkLookupTable.h>
 153
 154 // SALOME KERNEL includes
 155 #include <SALOMEDS_Study.hxx>
 156 #include <SALOMEDSClient_StudyBuilder.hxx>
 157 #include <SALOMEDSClient_SComponent.hxx>
 158 #include <SALOMEDSClient_ClientFactory.hxx>
 159 #include <SALOMEDSClient_IParameters.hxx>
 160
 161 // OCCT includes
 162 #include <Standard_ErrorHandler.hxx>
 163 #include <NCollection_DataMap.hxx>
 164
 165 //To disable automatic genericobj management, the following line should be commented.
 166 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
 167 #define WITHGENERICOBJ
 168
 169 //namespace{
 170   // Declarations
 171   //=============================================================
 172   void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
 173                             int theCommandID);
 174
 175   void ExportMeshToFile(int theCommandID);
 176
 177   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
 178
 179   void SetDisplayEntity(int theCommandID);
 180
 181   void Control( int theCommandID );
 182
 183
 184   // Definitions
 185   //=============================================================
 186   void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
 187                              int theCommandID )
 188   {
 189     QStringList filter;
 190     std::string myExtension;
 191
 192     if ( theCommandID == 113 ) {
 193       filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
 194       filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
 195     }
 196     else if ( theCommandID == 112 ) {
 197       filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
 198     }
 199     else if ( theCommandID == 111 ) {
 200       filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
 201     }
 202     else if ( theCommandID == 115 ) {
 203       filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
 204     }
 205     else if ( theCommandID == 116 ) {
 206       filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 207     }
 208     else if ( theCommandID == 117 ) {
 209       filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
 210       filter.append( QObject::tr( "All files (*)" ) );
 211     }
 212
 213     QString anInitialPath = "";
 214     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 215       anInitialPath = QDir::currentPath();
 216
 217     QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
 218                                                             anInitialPath,
 219                                                             filter,
 220                                                             QObject::tr( "SMESH_IMPORT_MESH" ) );
 221     if ( filenames.count() > 0 ) {
 222       SUIT_OverrideCursor wc;
 223       _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
 224
 225       QStringList errors;
 226       QStringList anEntryList;
 227       bool isEmpty = false;
 228       for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
 229         QString filename = *it;
 230         SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
 231         try {
 232           switch ( theCommandID ) {
 233           case 111:
 234             {
 235               // DAT format (currently unsupported)
 236               errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 237                              arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
 238               break;
 239             }
 240           case 112:
 241             {
 242               // UNV format
 243               aMeshes->length( 1 );
 244               aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
 245               if ( aMeshes[0]->_is_nil() )
 246                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 247                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 248               break;
 249             }
 250           case 113:
 251             {
 252               // MED format
 253               SMESH::DriverMED_ReadStatus res;
 254               aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
 255               if ( res != SMESH::DRS_OK ) {
 256                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 257                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 258               }
 259               break;
 260             }
 261           case 115:
 262             {
 263               // STL format
 264               aMeshes->length( 1 );
 265               aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
 266               if ( aMeshes[0]->_is_nil() ) {
 267                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 268                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 269               }
 270               break;
 271             }
 272           case 116:
 273             {
 274               // CGNS format
 275               SMESH::DriverMED_ReadStatus res;
 276               aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
 277               if ( res != SMESH::DRS_OK ) {
 278                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 279                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 280               }
 281               break;
 282             }
 283           case 117:
 284             {
 285               // SAUV format
 286               SMESH::DriverMED_ReadStatus res;
 287               aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
 288               if ( res != SMESH::DRS_OK ) {
 289                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 290                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 291               }
 292               break;
 293             }
 294           }
 295         }
 296         catch ( const SALOME::SALOME_Exception& S_ex ) {
 297           errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 298                          arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 299         }
 300
 301         for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
 302           _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
 303           if ( aMeshSO ) {
 304             _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
 305             _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
 306             aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
 307             if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
 308               SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
 309
 310             anEntryList.append( aMeshSO->GetID().c_str() );
 311
 312 #ifdef WITHGENERICOBJ
 313             // obj has been published in study. Its refcount has been incremented.
 314             // It is safe to decrement its refcount
 315             // so that it will be destroyed when the entry in study will be removed
 316             aMeshes[i]->UnRegister();
 317 #endif
 318           }
 319           else {
 320             isEmpty = true;
 321           }
 322         }
 323       }
 324
 325       // update Object browser
 326       SMESHGUI::GetSMESHGUI()->updateObjBrowser();
 327
 328       // browse to the published meshes
 329       if( LightApp_Application* anApp =
 330           dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
 331         anApp->browseObjects( anEntryList );
 332
 333       // show Error message box if there were errors
 334       if ( errors.count() > 0 ) {
 335         SUIT_MessageBox::critical( SMESHGUI::desktop(),
 336                                    QObject::tr( "SMESH_ERROR" ),
 337                                    QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
 338       }
 339
 340       // show warning message box, if some imported mesh is empty
 341       if ( isEmpty ) {
 342           SUIT_MessageBox::warning( SMESHGUI::desktop(),
 343                                     QObject::tr( "SMESH_WRN_WARNING" ),
 344                                     QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
 345       }
 346     }
 347   }
 348
 349   //================================================================================
 350   /*!
 351    * \brief Export selected meshes or groups into a file
 352    */
 353   //================================================================================
 354
 355   void ExportMeshToFile( int theCommandID )
 356   {
 357     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 358     SALOME_ListIO selected;
 359     if( aSel )
 360       aSel->selectedObjects( selected );
 361
 362     const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
 363     const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
 364     const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
 365     const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
 366     const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
 367     const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
 368
 369     // actually, the following condition can't be met (added for insurance)
 370     if( selected.Extent() == 0 ||
 371         ( selected.Extent() > 1 && !isMED && !isSTL ))
 372       return;
 373
 374     // get mesh object from selection and check duplication of their names
 375     bool hasDuplicatedMeshNames = false;
 376     QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
 377     QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
 378     SALOME_ListIteratorOfListIO It( selected );
 379     for( ; It.More(); It.Next() )
 380     {
 381       Handle(SALOME_InteractiveObject) anIObject = It.Value();
 382       SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
 383       if ( aMeshItem->_is_nil() ) {
 384         SUIT_MessageBox::warning( SMESHGUI::desktop(),
 385                                   QObject::tr( "SMESH_WRN_WARNING" ),
 386                                   QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
 387         return;
 388       }
 389
 390       QString aMeshName = anIObject->getName();
 391
 392       // check for name duplications
 393       if ( !hasDuplicatedMeshNames )
 394         for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 395           if( aMeshName == (*aMeshIter).second ) {
 396             hasDuplicatedMeshNames = true;
 397             break;
 398           }
 399         }
 400
 401       aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
 402     }
 403
 404     if( hasDuplicatedMeshNames && isMED ) {
 405       int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 406                                           QObject::tr("SMESH_WRN_WARNING"),
 407                                           QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
 408                                           QObject::tr("SMESH_BUT_YES"),
 409                                           QObject::tr("SMESH_BUT_NO"), 0, 1);
 410       if (aRet != 0)
 411         return;
 412     }
 413
 414     aMeshIter = aMeshList.begin();
 415     SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 416     SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
 417     QString aMeshName = (*aMeshIter).second;
 418
 419     if ( isMED || isCGNS || isSAUV )
 420     {
 421       // check for equal group names within each mesh
 422       for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 423         SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 424         if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
 425           int aRet = SUIT_MessageBox::warning
 426             (SMESHGUI::desktop(),
 427              QObject::tr("SMESH_WRN_WARNING"),
 428              QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
 429              QObject::tr("SMESH_BUT_YES"),
 430              QObject::tr("SMESH_BUT_NO"), 0, 1);
 431           if (aRet != 0)
 432             return;
 433         }
 434       }
 435     }
 436     else if ( isUNV )
 437     {
 438       // warn the user about presence of not supported elements
 439       SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
 440       int nbNotSupported = ( nbElems[ SMESH::Entity_Pyramid ] +
 441                              nbElems[ SMESH::Entity_Quad_Pyramid ] +
 442                              nbElems[ SMESH::Entity_Hexagonal_Prism ] +
 443                              nbElems[ SMESH::Entity_Polygon ] +
 444                              nbElems[ SMESH::Entity_Polyhedra ] );
 445       if ( nbNotSupported > 0 ) {
 446         int aRet = SUIT_MessageBox::warning
 447           (SMESHGUI::desktop(),
 448            QObject::tr("SMESH_WRN_WARNING"),
 449            QObject::tr("SMESH_EXPORT_UNV").arg(aMeshName),
 450            QObject::tr("SMESH_BUT_YES"),
 451            QObject::tr("SMESH_BUT_NO"), 0, 1);
 452         if (aRet != 0)
 453           return;
 454       }
 455     }
 456
 457     // Get parameters of export operation
 458
 459     QString aFilename;
 460     SMESH::MED_VERSION aFormat;
 461     // Init the parameters with the default values
 462     bool aIsASCII_STL = true;
 463     bool toCreateGroups = false;
 464     SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 465     if ( resMgr )
 466       toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
 467     bool toOverwrite = true;
 468
 469     QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
 470     QString anInitialPath = "";
 471     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 472       anInitialPath = QDir::currentPath();
 473
 474     if ( isUNV || isDAT )
 475     {
 476       if ( isUNV )
 477         aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
 478       else
 479         aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
 480       if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
 481       aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
 482                                             anInitialPath + QString("/") + aMeshName,
 483                                             aFilter, aTitle, false);
 484     }
 485     else if ( isCGNS )// Export to CGNS
 486     {
 487       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 488       fd->setWindowTitle( aTitle );
 489       fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 490       if ( !anInitialPath.isEmpty() )
 491         fd->setDirectory( anInitialPath );
 492       fd->selectFile(aMeshName);
 493       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 494       fd->setValidator( fv );
 495
 496       if ( fd->exec() )
 497         aFilename = fd->selectedFile();
 498       toOverwrite = fv->isOverwrite();
 499
 500       delete fd;
 501     }
 502     else if ( isSTL ) // Export to STL
 503     {
 504       QMap<QString, int> aFilterMap;
 505       aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
 506       aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" )   + " (*.stl)", 0 );
 507
 508       QStringList filters;
 509       QMap<QString, int>::const_iterator it = aFilterMap.begin();
 510       for ( ; it != aFilterMap.end(); ++it )
 511         filters.push_back( it.key() );
 512
 513       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 514       fd->setWindowTitle( aTitle );
 515       fd->setNameFilters( filters );
 516       fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
 517       if ( !anInitialPath.isEmpty() )
 518         fd->setDirectory( anInitialPath );
 519       fd->selectFile(aMeshName);
 520       bool is_ok = false;
 521       while (!is_ok) {
 522         if ( fd->exec() )
 523           aFilename = fd->selectedFile();
 524         aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
 525         is_ok = true;
 526       }
 527       delete fd;
 528     }
 529     else if ( isMED || isSAUV ) // Export to MED or SAUV
 530     {
 531       QMap<QString, SMESH::MED_VERSION> aFilterMap;
 532       //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
 533       if ( isMED ) {
 534         QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
 535         //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
 536         aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
 537       }
 538       else { // isSAUV
 539         aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
 540         aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
 541         aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
 542       }
 543
 544       QStringList filters;
 545       QString aDefaultFilter;
 546       QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
 547       for ( ; it != aFilterMap.end(); ++it ) {
 548         filters.push_back( it.key() );
 549         if (it.value() == SMESH::MED_V2_2)
 550           aDefaultFilter = it.key();
 551       }
 552
 553       SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
 554         ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
 555       fd->setWindowTitle( aTitle );
 556       fd->setNameFilters( filters );
 557       fd->selectNameFilter(aDefaultFilter);
 558       fd->SetChecked(toCreateGroups);
 559       if ( !anInitialPath.isEmpty() )
 560         fd->setDirectory( anInitialPath );
 561       fd->selectFile(aMeshName);
 562
 563       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 564       fd->setValidator( fv );
 565
 566       bool is_ok = false;
 567       while (!is_ok) {
 568         if ( fd->exec() )
 569           aFilename = fd->selectedFile();
 570         else {
 571           aFilename = QString::null;
 572           break;
 573         }
 574         aFormat = aFilterMap[fd->selectedNameFilter()];
 575         toOverwrite = fv->isOverwrite();
 576         is_ok = true;
 577         if ( !aFilename.isEmpty() ) {
 578           // med-2.1 does not support poly elements
 579           if ( aFormat==SMESH::MED_V2_1 )
 580             for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 581               SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
 582               SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
 583               if ( nbElems[ SMESH::Entity_Polygon   ] + nbElems[ SMESH::Entity_Quad_Polygon   ] +
 584                    nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
 585               {
 586                 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 587                                                     QObject::tr("SMESH_WRN_WARNING"),
 588                                                     QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
 589                                                     QObject::tr("SMESH_BUT_YES"),
 590                                                     QObject::tr("SMESH_BUT_NO"), 0, 1);
 591                 if (aRet != 0) {
 592                   is_ok = false;
 593                   break;
 594                 }
 595               }
 596             }
 597           if( !toOverwrite ) {
 598             // can't append to an existing using other format
 599             SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
 600             bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
 601             if( !isVersionOk || aVersion != aFormat ) {
 602               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 603                                                   QObject::tr("SMESH_WRN_WARNING"),
 604                                                   QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
 605                                                   QObject::tr("SMESH_BUT_YES"),
 606                                                   QObject::tr("SMESH_BUT_NO"), 0, 1);
 607               if (aRet == 0)
 608                 toOverwrite = true;
 609               else
 610                 is_ok = false;
 611             }
 612
 613             QStringList aMeshNamesCollisionList;
 614             SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
 615             for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
 616               QString anExistingMeshName( aMeshNames[ i ] );
 617               for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 618                 QString anExportMeshName = (*aMeshIter).second;
 619                 if( anExportMeshName == anExistingMeshName ) {
 620                   aMeshNamesCollisionList.append( anExportMeshName );
 621                   break;
 622                 }
 623               }
 624             }
 625             if( !aMeshNamesCollisionList.isEmpty() ) {
 626               QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
 627               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 628                                                   QObject::tr("SMESH_WRN_WARNING"),
 629                                                   QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
 630                                                   QObject::tr("SMESH_BUT_YES"),
 631                                                   QObject::tr("SMESH_BUT_NO"),
 632                                                   QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
 633               if (aRet == 0)
 634                 toOverwrite = true;
 635               else if (aRet == 2)
 636                 is_ok = false;
 637             }
 638           }
 639         }
 640       }
 641       toCreateGroups = fd->IsChecked();
 642       delete fd;
 643     }
 644     else
 645     {
 646       return;
 647     }
 648
 649     // Perform export
 650
 651     if ( !aFilename.isEmpty() ) {
 652       // Check whether the file already exists and delete it if yes
 653       QFile aFile( aFilename );
 654       if ( aFile.exists() && toOverwrite )
 655         aFile.remove();
 656       SUIT_OverrideCursor wc;
 657
 658       try {
 659         // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
 660 //         bool Renumber = false;
 661 //         // PAL 14172  : Check of we have to renumber or not from the preferences before export
 662 //         if (resMgr)
 663 //           Renumber= resMgr->booleanValue("SMESH","renumbering");
 664 //         if (Renumber){
 665 //           SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
 666 //           aMeshEditor->RenumberNodes();
 667 //           aMeshEditor->RenumberElements();
 668 //           if ( SMESHGUI::automaticUpdate() )
 669 //             SMESH::UpdateView();
 670 //         }
 671         if ( isMED )
 672         {
 673           aMeshIter = aMeshList.begin();
 674           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 675           {
 676             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 677             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 678             if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
 679               aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
 680                                        aFormat, toOverwrite && aMeshIndex == 0 );
 681             else
 682               aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
 683                                           aFormat, toOverwrite && aMeshIndex == 0 );
 684           }
 685         }
 686         else if ( isSAUV )
 687         {
 688           for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
 689           {
 690             SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 691             if( !aMeshItem->_is_nil() )
 692               aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
 693           }
 694         }
 695         else if ( isDAT )
 696         {
 697           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 698             aMesh->ExportDAT( aFilename.toLatin1().data() );
 699           else
 700             aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
 701         }
 702         else if ( isUNV )
 703         {
 704           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 705             aMesh->ExportUNV( aFilename.toLatin1().data() );
 706           else
 707             aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
 708         }
 709         else if ( isSTL )
 710         {
 711           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 712             aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
 713           else
 714             aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
 715         }
 716         else if ( isCGNS )
 717         {
 718           aMeshIter = aMeshList.begin();
 719           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 720           {
 721             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 722             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 723             aMeshItem->ExportCGNS( aMeshOrGroup,
 724                                    aFilename.toLatin1().data(),
 725                                    toOverwrite && aMeshIndex == 0 );
 726           }
 727         }
 728       }
 729       catch (const SALOME::SALOME_Exception& S_ex){
 730         wc.suspend();
 731         SUIT_MessageBox::warning(SMESHGUI::desktop(),
 732                                  QObject::tr("SMESH_WRN_WARNING"),
 733                                  QObject::tr("SMESH_EXPORT_FAILED"));
 734         wc.resume();
 735       }
 736     }
 737   }
 738
 739   inline void InverseEntityMode(unsigned int& theOutputMode,
 740                                 unsigned int theMode)
 741   {
 742     bool anIsNotPresent = ~theOutputMode & theMode;
 743     if(anIsNotPresent)
 744       theOutputMode |= theMode;
 745     else
 746       theOutputMode &= ~theMode;
 747   }
 748
 749   void SetDisplayEntity(int theCommandID){
 750     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 751     SALOME_ListIO selected;
 752     if( aSel )
 753       aSel->selectedObjects( selected );
 754
 755     if(selected.Extent() >= 1){
 756       SALOME_ListIteratorOfListIO It( selected );
 757       for( ; It.More(); It.Next()){
 758         Handle(SALOME_InteractiveObject) IObject = It.Value();
 759         if(IObject->hasEntry()){
 760           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
 761             unsigned int aMode = anActor->GetEntityMode();
 762             switch(theCommandID){
 763             case 216:
 764               InverseEntityMode(aMode,SMESH_Actor::e0DElements);
 765               break;
 766             case 217:
 767               InverseEntityMode(aMode,SMESH_Actor::eEdges);
 768               break;
 769             case 218:
 770               InverseEntityMode(aMode,SMESH_Actor::eFaces);
 771               break;
 772             case 219:
 773               InverseEntityMode(aMode,SMESH_Actor::eVolumes);
 774               break;
 775             case 220:
 776               aMode = SMESH_Actor::eAllEntity;
 777               break;
 778             }
 779             if(aMode)
 780               anActor->SetEntityMode(aMode);
 781           }
 782         }
 783       }
 784     }
 785   }
 786
 787   void AutoColor(){
 788     SALOME_ListIO selected;
 789     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 790     if( !app )
 791       return;
 792
 793     LightApp_SelectionMgr* aSel = app->selectionMgr();
 794     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
 795     if( !aSel || !appStudy )
 796       return;
 797
 798     aSel->selectedObjects( selected );
 799     if( selected.IsEmpty() )
 800       return;
 801
 802     Handle(SALOME_InteractiveObject) anIObject = selected.First();
 803
 804     _PTR(Study) aStudy = appStudy->studyDS();
 805     _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
 806     SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
 807     if( aMainObject->_is_nil() )
 808       return;
 809
 810     aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
 811
 812     SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
 813     for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
 814     {
 815       SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
 816       SALOMEDS::Color aColor = aGroupObject->GetColor();
 817       _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
 818       if (aGroupSObject) {
 819         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
 820           if( aGroupObject->GetType() == SMESH::NODE )
 821             anActor->SetNodeColor( aColor.R, aColor.G, aColor.B );
 822           else if( aGroupObject->GetType() == SMESH::EDGE )
 823             anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B );
 824           else if( aGroupObject->GetType() == SMESH::ELEM0D )
 825             anActor->Set0DColor( aColor.R, aColor.G, aColor.B );
 826           else {
 827             QColor c;
 828             int delta;
 829             SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
 830             anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
 831           }
 832         }
 833       }
 834     }
 835
 836     SMESH::RepaintCurrentView();
 837   }
 838
 839   QString functorToString( SMESH::Controls::FunctorPtr f )
 840   {
 841     QString type = QObject::tr( "UNKNOWN_CONTROL" );
 842     if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
 843       type = QObject::tr( "VOLUME_3D_ELEMENTS" );
 844     else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
 845       type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
 846     else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
 847       type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
 848     else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
 849       type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
 850     else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
 851       type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
 852     else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
 853       type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
 854     else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
 855       type = QObject::tr( "WARP_ELEMENTS" );
 856     else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
 857       type = QObject::tr( "TAPER_ELEMENTS" );
 858     else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
 859       type = QObject::tr( "SKEW_ELEMENTS" );
 860     else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
 861       type = QObject::tr( "AREA_ELEMENTS" );
 862     else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
 863       type = QObject::tr( "LENGTH_EDGES" );
 864     else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
 865       type = QObject::tr( "LENGTH2D_EDGES" );
 866     else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
 867       type = QObject::tr( "MULTI_BORDERS" );
 868     else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
 869       type = QObject::tr( "MULTI2D_BORDERS" );
 870     else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
 871       type = QObject::tr( "FREE_NODES" );
 872     else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
 873       type = QObject::tr( "FREE_EDGES" );
 874     else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
 875       type = QObject::tr( "FREE_BORDERS" );
 876     else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
 877       type = QObject::tr( "FREE_FACES" );
 878     else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
 879       type = QObject::tr( "BARE_BORDER_VOLUME" );
 880     else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
 881       type = QObject::tr( "BARE_BORDER_FACE" );
 882     else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
 883       type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
 884     else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
 885       type = QObject::tr( "OVER_CONSTRAINED_FACE" );
 886     else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
 887       type = QObject::tr( "EQUAL_NODE" );
 888     else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
 889       type = QObject::tr( "EQUAL_EDGE" );
 890     else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
 891       type = QObject::tr( "EQUAL_FACE" );
 892     else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
 893       type = QObject::tr( "EQUAL_VOLUME" );
 894     return type;
 895   }
 896
 897   void SaveDistribution()
 898   {
 899     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
 900     SALOME_ListIO selected;
 901     if ( aSel )
 902       aSel->selectedObjects( selected );
 903
 904     if ( selected.Extent() == 1 ) {
 905       Handle(SALOME_InteractiveObject) anIO = selected.First();
 906       if ( anIO->hasEntry() ) {
 907         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
 908         if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
 909           SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
 910           SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
 911           if ( aScalarBarActor && aFunctor ) {
 912             SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
 913             if ( aNumFun ) {
 914               std::vector<int> elements;
 915               SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
 916               if ( mesh->_is_nil() ) {
 917                 SMESH::SMESH_IDSource_var idSource =
 918                   SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
 919                 if ( !idSource->_is_nil() )
 920                 {
 921                   SMESH::long_array_var ids = idSource->GetIDs();
 922                   elements.resize( ids->length() );
 923                   for ( unsigned i = 0; i < elements.size(); ++i )
 924                     elements[i] = ids[i];
 925                 }
 926               }
 927               int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
 928               vtkLookupTable* lookupTable =
 929                 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
 930               double * minmax = lookupTable->GetRange();
 931               std::vector<int>    nbEvents;
 932               std::vector<double> funValues;
 933               aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
 934               QString anInitialPath = "";
 935               if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 936                 anInitialPath = QDir::currentPath();
 937               QString aMeshName = anIO->getName();
 938               QStringList filter;
 939               filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
 940               filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
 941               QString aFilename = anInitialPath + "/" + aMeshName + "_" +
 942                 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
 943               aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
 944                                                      aFilename,
 945                                                      filter,
 946                                                      QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
 947                                                      false );
 948               if ( !aFilename.isEmpty() ) {
 949                 QFile f( aFilename );
 950                 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
 951                   QTextStream out( &f );
 952                   out << "# Mesh: " << aMeshName << endl;
 953                   out << "# Control: " << functorToString( aFunctor ) << endl;
 954                   out << "#" << endl;
 955                   out.setFieldWidth( 10 );
 956                   for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
 957                     out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
 958                   f.close();
 959                 }
 960               }
 961             }
 962           }
 963         }
 964       }
 965     }
 966   }
 967
 968   void ShowDistribution() {
 969     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
 970     SALOME_ListIO selected;
 971     if ( aSel )
 972       aSel->selectedObjects( selected );
 973
 974     if ( selected.Extent() == 1 ) {
 975       Handle(SALOME_InteractiveObject) anIO = selected.First();
 976       if ( anIO->hasEntry() ) {
 977         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
 978         if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
 979           SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
 980           aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
 981         }
 982       }
 983     }
 984   }
 985
 986 #ifndef DISABLE_PLOT2DVIEWER
 987  void PlotDistribution() {
 988    SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 989    if( !app )
 990      return;
 991
 992    LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
 993    SALOME_ListIO selected;
 994    if ( aSel )
 995      aSel->selectedObjects( selected );
 996
 997    if ( selected.Extent() == 1 ) {
 998      Handle(SALOME_InteractiveObject) anIO = selected.First();
 999      if ( anIO->hasEntry() ) {
1000        //Find Actor by entry before getting Plot2d viewer,
1001        //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1002        SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1003
1004        SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1005
1006        if( !aViewManager )
1007          return;
1008
1009        SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1010        if ( !aView )
1011          return;
1012
1013        Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1014        if ( !aPlot )
1015          return;
1016
1017        if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1018          SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1019          QString functorName = functorToString( anActor->GetFunctor());
1020          QString aHistogramName("%1 : %2");
1021          aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1022          aHistogram->setName(aHistogramName);
1023          aHistogram->setHorTitle(functorName);
1024          aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1025          aPlot->displayObject(aHistogram, true);
1026        }
1027      }
1028    }
1029  }
1030 #endif //DISABLE_PLOT2DVIEWER
1031
1032   void DisableAutoColor(){
1033     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1034     SALOME_ListIO selected;
1035     if( aSel )
1036       aSel->selectedObjects( selected );
1037
1038     if(selected.Extent()){
1039       Handle(SALOME_InteractiveObject) anIObject = selected.First();
1040       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1041       if ( !aMesh->_is_nil() ) {
1042         aMesh->SetAutoColor( false );
1043       }
1044     }
1045   }
1046
1047   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap){
1048     SALOME_ListIO selected;
1049     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1050     if( !app )
1051       return;
1052
1053     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1054     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1055     if( !aSel || !appStudy )
1056       return;
1057
1058     if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1059       if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1060         aModule->EmitSignalDeactivateDialog();
1061         if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1062           (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1063       }
1064       return;
1065     }
1066
1067     _PTR(Study) aStudy = appStudy->studyDS();
1068
1069     aSel->selectedObjects( selected );
1070
1071     if(selected.Extent() >= 1){
1072       switch(theCommandID){
1073       case 1133:{
1074         SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1075         (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1076         return;
1077       }
1078       case 1132:{
1079         QColor c, e, b, n, c0D, o, outl, selection, preselection;
1080         int delta;
1081         int size0D = 0;
1082         int Edgewidth = 0;
1083         vtkFloatingPointType Shrink = 0.0;
1084         vtkFloatingPointType faces_orientation_scale = 0.0;
1085         bool faces_orientation_3dvectors = false;
1086
1087         VTK::MarkerType aMarkerTypeCurrent = VTK::MT_NONE;
1088         VTK::MarkerScale aMarkerScaleCurrent = VTK::MS_NONE;
1089         int aMarkerTextureCurrent = 0;
1090
1091         SALOME_ListIteratorOfListIO It( selected );
1092         for( ; It.More(); It.Next()){
1093           Handle(SALOME_InteractiveObject) IObject = It.Value();
1094           if(IObject->hasEntry()){
1095             if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1096               vtkFloatingPointType color[3];
1097               anActor->GetSufaceColor(color[0], color[1], color[2],delta);
1098               int c0 = int (color[0] * 255);
1099               int c1 = int (color[1] * 255);
1100               int c2 = int (color[2] * 255);
1101               c.setRgb(c0, c1, c2);
1102
1103               vtkFloatingPointType edgecolor[3];
1104               anActor->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]);
1105               c0 = int (edgecolor[0] * 255);
1106               c1 = int (edgecolor[1] * 255);
1107               c2 = int (edgecolor[2] * 255);
1108               e.setRgb(c0, c1, c2);
1109
1110               vtkFloatingPointType nodecolor[3];
1111               anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]);
1112               c0 = int (nodecolor[0] * 255);
1113               c1 = int (nodecolor[1] * 255);
1114               c2 = int (nodecolor[2] * 255);
1115               n.setRgb(c0, c1, c2);
1116
1117               vtkFloatingPointType color0D[3];
1118               anActor->Get0DColor(color0D[0], color0D[1], color0D[2]);
1119               c0 = int (color0D[0] * 255);
1120               c1 = int (color0D[1] * 255);
1121               c2 = int (color0D[2] * 255);
1122               c0D.setRgb(c0, c1, c2);
1123
1124               vtkFloatingPointType outlineColor[3];
1125               anActor->GetOutlineColor(outlineColor[0], outlineColor[1], outlineColor[2]);
1126               c0 = int (outlineColor[0] * 255);
1127               c1 = int (outlineColor[1] * 255);
1128               c2 = int (outlineColor[2] * 255);
1129               outl.setRgb(c0, c1, c2);
1130
1131               vtkFloatingPointType hColor[3];
1132               anActor->GetHighlightColor(hColor[0], hColor[1], hColor[2]);
1133               c0 = int (hColor[0] * 255);
1134               c1 = int (hColor[1] * 255);
1135               c2 = int (hColor[2] * 255);
1136               selection.setRgb(c0, c1, c2);
1137
1138               vtkFloatingPointType phColor[3];
1139               anActor->GetPreHighlightColor(phColor[0], phColor[1], phColor[2]);
1140               c0 = int (phColor[0] * 255);
1141               c1 = int (phColor[1] * 255);
1142               c2 = int (phColor[2] * 255);
1143               preselection.setRgb(c0, c1, c2);
1144
1145               size0D = (int)anActor->Get0DSize();
1146               if(size0D == 0)
1147                 size0D = 1;
1148               Edgewidth = (int)anActor->GetLineWidth();
1149               if(Edgewidth == 0)
1150                 Edgewidth = 1;
1151               Shrink = anActor->GetShrinkFactor();
1152
1153               vtkFloatingPointType faces_orientation_color[3];
1154               anActor->GetFacesOrientationColor(faces_orientation_color);
1155               c0 = int (faces_orientation_color[0] * 255);
1156               c1 = int (faces_orientation_color[1] * 255);
1157               c2 = int (faces_orientation_color[2] * 255);
1158               o.setRgb(c0, c1, c2);
1159
1160               faces_orientation_scale = anActor->GetFacesOrientationScale();
1161               faces_orientation_3dvectors = anActor->GetFacesOrientation3DVectors();
1162
1163               aMarkerTypeCurrent = anActor->GetMarkerType();
1164               aMarkerScaleCurrent = anActor->GetMarkerScale();
1165               aMarkerTextureCurrent = anActor->GetMarkerTexture();
1166
1167               // even if there are multiple objects in the selection,
1168               // we need only the first one to get values for the dialog
1169               break;
1170             }
1171           }
1172         }
1173
1174         SMESHGUI_Preferences_ColorDlg *aDlg =
1175           new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI() );
1176         aDlg->SetColor(1, c);
1177         aDlg->SetColor(2, e);
1178         aDlg->SetColor(3, n);
1179         aDlg->SetColor(4, outl);
1180         aDlg->SetDeltaBrightness(delta);
1181         aDlg->SetColor(5, c0D);
1182         aDlg->SetColor(6, o);
1183         aDlg->SetIntValue(1, Edgewidth);
1184         aDlg->SetIntValue(2, int(Shrink*100.));
1185         aDlg->SetIntValue(3, size0D);
1186         aDlg->SetDoubleValue(1, faces_orientation_scale);
1187         aDlg->SetBooleanValue(1, faces_orientation_3dvectors);
1188         aDlg->SetColor(7, selection);
1189         aDlg->SetColor(8, preselection);
1190
1191         aDlg->setCustomMarkerMap( theMarkerMap[ aStudy->StudyId() ] );
1192
1193         if( aMarkerTypeCurrent != VTK::MT_USER )
1194           aDlg->setStandardMarker( aMarkerTypeCurrent, aMarkerScaleCurrent );
1195         else
1196           aDlg->setCustomMarker( aMarkerTextureCurrent );
1197
1198         if(aDlg->exec()){
1199           QColor color = aDlg->GetColor(1);
1200           QColor edgecolor = aDlg->GetColor(2);
1201           QColor nodecolor = aDlg->GetColor(3);
1202           QColor outlinecolor = aDlg->GetColor(4);
1203           QColor color0D = aDlg->GetColor(5);
1204           QColor faces_orientation_color = aDlg->GetColor(6);
1205           QColor selectioncolor = aDlg->GetColor(7);
1206           QColor preSelectioncolor = aDlg->GetColor(8);
1207           int delta = aDlg->GetDeltaBrightness();
1208
1209           /* Point marker */
1210           theMarkerMap[ aStudy->StudyId() ] = aDlg->getCustomMarkerMap();
1211
1212           SALOME_ListIteratorOfListIO It( selected );
1213           for( ; It.More(); It.Next()){
1214             Handle(SALOME_InteractiveObject) IObject = It.Value();
1215             if(IObject->hasEntry()){
1216               if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1217                 /* actor color and backface color */
1218                 anActor->SetSufaceColor(vtkFloatingPointType (color.red()) / 255.,
1219                                         vtkFloatingPointType (color.green()) / 255.,
1220                                         vtkFloatingPointType (color.blue()) / 255.,
1221                                         delta);
1222                 /* edge color */
1223                 anActor->SetEdgeColor(vtkFloatingPointType (edgecolor.red()) / 255.,
1224                                       vtkFloatingPointType (edgecolor.green()) / 255.,
1225                                       vtkFloatingPointType (edgecolor.blue()) / 255.);
1226                 /* edge outline */
1227                 anActor->SetOutlineColor(vtkFloatingPointType (outlinecolor.red()) / 255.,
1228                                          vtkFloatingPointType (outlinecolor.green()) / 255.,
1229                                          vtkFloatingPointType (outlinecolor.blue()) / 255.);
1230
1231                 /* selection */
1232                 anActor->SetHighlightColor(vtkFloatingPointType (selectioncolor.red()) / 255.,
1233                                            vtkFloatingPointType (selectioncolor.green()) / 255.,
1234                                            vtkFloatingPointType (selectioncolor.blue()) / 255.);
1235                 /* pre-selection */
1236                 anActor->SetPreHighlightColor(vtkFloatingPointType (preSelectioncolor.red()) / 255.,
1237                                               vtkFloatingPointType (preSelectioncolor.green()) / 255.,
1238                                               vtkFloatingPointType (preSelectioncolor.blue()) / 255.);
1239
1240
1241                 /* Shrink factor and size edges */
1242                 anActor->SetShrinkFactor(aDlg->GetIntValue(2) / 100.);
1243                 anActor->SetLineWidth(aDlg->GetIntValue(1));
1244
1245                 /* Nodes color and size */
1246                 anActor->SetNodeColor(vtkFloatingPointType (nodecolor.red()) / 255.,
1247                                       vtkFloatingPointType (nodecolor.green()) / 255.,
1248                                       vtkFloatingPointType (nodecolor.blue()) / 255.);
1249
1250                 /* 0D elements */
1251                 anActor->Set0DColor(vtkFloatingPointType (color0D.red()) / 255.,
1252                                     vtkFloatingPointType (color0D.green()) / 255.,
1253                                     vtkFloatingPointType (color0D.blue()) / 255.);
1254                 anActor->Set0DSize(aDlg->GetIntValue(3));
1255
1256                 /* Faces orientation */
1257                 vtkFloatingPointType c[3] = {vtkFloatingPointType(faces_orientation_color.redF()),
1258                                              vtkFloatingPointType(faces_orientation_color.greenF()),
1259                                              vtkFloatingPointType(faces_orientation_color.blueF())};
1260                 anActor->SetFacesOrientationColor(c);
1261                 anActor->SetFacesOrientationScale(aDlg->GetDoubleValue(1));
1262                 anActor->SetFacesOrientation3DVectors(aDlg->GetBooleanValue(1));
1263
1264                 VTK::MarkerType aMarkerTypeNew = aDlg->getMarkerType();
1265                 VTK::MarkerScale aMarkerScaleNew = aDlg->getStandardMarkerScale();
1266                 int aMarkerTextureNew = aDlg->getCustomMarkerID();
1267                 if( aMarkerTypeNew != VTK::MT_USER )
1268                   anActor->SetMarkerStd( aMarkerTypeNew, aMarkerScaleNew );
1269                 else {
1270                   const VTK::MarkerMap& aMarkerMap = theMarkerMap[ aStudy->StudyId() ];
1271                   VTK::MarkerMap::const_iterator anIter = aMarkerMap.find( aMarkerTextureNew );
1272                   if( anIter != aMarkerMap.end() )
1273                     anActor->SetMarkerTexture( aMarkerTextureNew, anIter->second.second );
1274                 }
1275
1276                 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1277                 if( !aGroupObject->_is_nil() )
1278                 {
1279                   SMESH::ElementType anElementType = aGroupObject->GetType();
1280                   QColor aColor;
1281                   switch( anElementType )
1282                   {
1283                     case SMESH::NODE: aColor = nodecolor; break;
1284                     case SMESH::EDGE: aColor = edgecolor; break;
1285                     default: aColor = color; break;
1286                   }
1287
1288                   SALOMEDS::Color aGroupColor;
1289                   aGroupColor.R = (float)aColor.red() / 255.0;
1290                   aGroupColor.G = (float)aColor.green() / 255.0;
1291                   aGroupColor.B = (float)aColor.blue() / 255.0;
1292                   aGroupObject->SetColor( aGroupColor );
1293                 }
1294               }
1295             }
1296           }
1297           SMESH::RepaintCurrentView();
1298         }
1299         delete aDlg;
1300         return;
1301       }
1302       }
1303       SALOME_ListIteratorOfListIO It( selected );
1304       for( ; It.More(); It.Next()){
1305         Handle(SALOME_InteractiveObject) IObject = It.Value();
1306         if(IObject->hasEntry()){
1307           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1308             switch(theCommandID){
1309             case 211:
1310               anActor->SetRepresentation(SMESH_Actor::eEdge);
1311               break;
1312             case 212:
1313               anActor->SetRepresentation(SMESH_Actor::eSurface);
1314               break;
1315             case 213:
1316               if(anActor->IsShrunk())
1317                 anActor->UnShrink();
1318               else
1319                 anActor->SetShrink();
1320               break;
1321             case 215:
1322               anActor->SetRepresentation(SMESH_Actor::ePoint);
1323               break;
1324             case 231:
1325               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1326                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1327               break;
1328             case 232:
1329               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1330                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1331               break;
1332             }
1333           }
1334         }
1335       }
1336       SMESH::RepaintCurrentView();
1337     }
1338   }
1339
1340   void Control( int theCommandID )
1341   {
1342     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1343     SALOME_ListIO selected;
1344     if( aSel )
1345       aSel->selectedObjects( selected );
1346
1347     if( !selected.IsEmpty() ){
1348       Handle(SALOME_InteractiveObject) anIO = selected.First();
1349       if(!anIO.IsNull()){
1350         SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1351         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1352           switch ( theCommandID ){
1353           case 6001:
1354             aControl = SMESH_Actor::eLength;
1355             break;
1356           case 6018:
1357             aControl = SMESH_Actor::eLength2D;
1358             break;
1359           case 6002:
1360             aControl = SMESH_Actor::eFreeEdges;
1361             break;
1362           case 6003:
1363             aControl = SMESH_Actor::eFreeBorders;
1364             break;
1365           case 6004:
1366             aControl = SMESH_Actor::eMultiConnection;
1367             break;
1368           case 6005:
1369             aControl = SMESH_Actor::eFreeNodes;
1370             break;
1371           case 6019:
1372             aControl = SMESH_Actor::eMultiConnection2D;
1373             break;
1374           case 6011:
1375             aControl = SMESH_Actor::eArea;
1376             break;
1377           case 6012:
1378             aControl = SMESH_Actor::eTaper;
1379             break;
1380           case 6013:
1381             aControl = SMESH_Actor::eAspectRatio;
1382             break;
1383           case 6017:
1384             aControl = SMESH_Actor::eAspectRatio3D;
1385             break;
1386           case 6014:
1387             aControl = SMESH_Actor::eMinimumAngle;
1388             break;
1389           case 6015:
1390             aControl = SMESH_Actor::eWarping;
1391             break;
1392           case 6016:
1393             aControl = SMESH_Actor::eSkew;
1394             break;
1395           case 6009:
1396             aControl = SMESH_Actor::eVolume3D;
1397             break;
1398           case 6021:
1399             aControl = SMESH_Actor::eFreeFaces;
1400             break;
1401           case 6022:
1402             aControl = SMESH_Actor::eMaxElementLength2D;
1403             break;
1404           case 6023:
1405             aControl = SMESH_Actor::eMaxElementLength3D;
1406             break;
1407           case 6024:
1408             aControl = SMESH_Actor::eBareBorderVolume;
1409             break;
1410           case 6025:
1411             aControl = SMESH_Actor::eBareBorderFace;
1412             break;
1413           case 6026:
1414             aControl = SMESH_Actor::eOverConstrainedVolume;
1415             break;
1416           case 6027:
1417             aControl = SMESH_Actor::eOverConstrainedFace;
1418             break;
1419           case 6028:
1420             aControl = SMESH_Actor::eCoincidentNodes;
1421             break;
1422           case 6029:
1423             aControl = SMESH_Actor::eCoincidentElems1D;
1424             break;
1425           case 6030:
1426             aControl = SMESH_Actor:: eCoincidentElems2D;
1427             break;
1428           case 6031:
1429             aControl = SMESH_Actor::eCoincidentElems3D;
1430             break;
1431           }
1432
1433           anActor->SetControlMode(aControl);
1434           anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1435           SMESH::RepaintCurrentView();
1436 #ifndef DISABLE_PLOT2DVIEWER
1437           if(anActor->GetPlot2Histogram()) {
1438             SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1439             QString functorName = functorToString( anActor->GetFunctor());
1440             QString aHistogramName("%1 : %2");
1441             aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1442             aHistogram->setName(aHistogramName);
1443             aHistogram->setHorTitle(functorName);
1444             SMESH::ProcessIn2DViewers(anActor);
1445           }
1446 #endif
1447         }
1448       }
1449     }
1450   }
1451
1452
1453   bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1454                    MeshObjectType                           theType,
1455                    const QString                            theInTypeName,
1456                    QString &                                theOutTypeName)
1457   {
1458     SMESH_TypeFilter aTypeFilter( theType );
1459     QString entry;
1460     if( !theIO.IsNull() )
1461     {
1462       entry = theIO->getEntry();
1463       LightApp_DataOwner owner( entry );
1464       if ( aTypeFilter.isOk( &owner )) {
1465         theOutTypeName = theInTypeName;
1466         return true;
1467       }
1468     }
1469     return false;
1470   }
1471
1472
1473   QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1474   {
1475     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1476     _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1477     if (aSObj) {
1478       _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1479       CORBA::String_var anID = aSComp->GetID().c_str();
1480       if (!strcmp(anID.in(),theIO->getEntry()))
1481         return "Component";
1482     }
1483
1484     QString aTypeName;
1485     if (
1486         CheckOIType ( theIO, HYPOTHESIS,    "Hypothesis", aTypeName ) ||
1487         CheckOIType ( theIO, ALGORITHM,     "Algorithm",  aTypeName ) ||
1488         CheckOIType ( theIO, MESH,          "Mesh",       aTypeName ) ||
1489         CheckOIType ( theIO, SUBMESH,       "SubMesh",    aTypeName ) ||
1490         CheckOIType ( theIO, GROUP,         "Group",      aTypeName )
1491         )
1492       return aTypeName;
1493
1494     return "NoType";
1495   }
1496
1497
1498   QString CheckHomogeneousSelection()
1499   {
1500     //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1501     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1502     SALOME_ListIO selected;
1503     if( aSel )
1504       aSel->selectedObjects( selected );
1505
1506     QString RefType = CheckTypeObject(selected.First());
1507     SALOME_ListIteratorOfListIO It(selected);
1508     for ( ; It.More(); It.Next())
1509       {
1510         Handle(SALOME_InteractiveObject) IObject = It.Value();
1511         QString Type = CheckTypeObject(IObject);
1512         if (Type.compare(RefType) != 0)
1513           return "Heterogeneous Selection";
1514       }
1515
1516     return RefType;
1517   }
1518
1519
1520   void SMESHGUI::OnEditDelete()
1521   {
1522     // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1523     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1524     SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1525
1526     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1527     _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1528     _PTR(GenericAttribute) anAttr;
1529     _PTR(AttributeIOR) anIOR;
1530
1531     int objectCount = 0;
1532     QString aNameList;
1533     QString aParentComponent = QString::null;
1534     Handle(SALOME_InteractiveObject) anIO;
1535     for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1536     {
1537       anIO = anIt.Value();
1538       QString cur = anIO->getComponentDataType();
1539       _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1540       if (aSO) {
1541         // check if object is reference
1542         _PTR(SObject) aRefSObj;
1543         aNameList.append("\n    - ");
1544         if ( aSO->ReferencedObject( aRefSObj ) ) {
1545           QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1546           aNameList.append( aRefName );
1547           cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1548         }
1549         else
1550           aNameList.append(anIO->getName());
1551         objectCount++;
1552       }
1553
1554       if( aParentComponent.isNull() )
1555         aParentComponent = cur;
1556       else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1557         aParentComponent = "";
1558     }
1559
1560     if ( objectCount == 0 )
1561       return; // No Valid Objects Selected
1562
1563     if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() )  {
1564       SUIT_MessageBox::warning( SMESHGUI::desktop(),
1565                                 QObject::tr("ERR_ERROR"),
1566                                 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1567       return;
1568     }
1569     // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1570     if (SUIT_MessageBox::warning
1571         (SMESHGUI::desktop(),
1572          QObject::tr("SMESH_WRN_WARNING"),
1573          QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1574          SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1575          SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1576       return;
1577
1578     SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1579
1580       SALOME_ListIteratorOfListIO It(selected);
1581
1582       aStudyBuilder->NewCommand();  // There is a transaction
1583       for( ; It.More(); It.Next()){ // loop on selected IO's
1584         Handle(SALOME_InteractiveObject) IObject = It.Value();
1585         if(IObject->hasEntry()) {
1586           _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1587
1588           // disable removal of "SMESH" component object
1589           if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1590             anIOR = anAttr;
1591             if ( engineIOR() == anIOR->Value().c_str() )
1592               continue;
1593           }
1594           //Check the referenced object
1595           _PTR(SObject) aRefSObject;
1596           if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1597             aSO = aRefSObject; // Delete main Object instead of reference
1598
1599           // put the whole hierarchy of sub-objects of the selected SO into a list and
1600           // then treat them all starting from the deepest objects (at list back)
1601
1602           std::list< _PTR(SObject) > listSO;
1603           listSO.push_back( aSO );
1604           std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1605           for ( ; itSO != listSO.end(); ++itSO ) {
1606             _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1607             for (it->InitEx(false); it->More(); it->Next())
1608               listSO.push_back( it->Value() );
1609           }
1610
1611           // treat SO's in the list starting from the back
1612
1613           std::list< _PTR(SObject) >::reverse_iterator ritSO = listSO.rbegin();
1614           for ( ; ritSO != listSO.rend(); ++ritSO ) {
1615             _PTR(SObject) SO = *ritSO;
1616             if ( !SO ) continue;
1617             std::string anEntry = SO->GetID();
1618
1619             /** Erase graphical object **/
1620           if(SO->FindAttribute(anAttr, "AttributeIOR")){
1621             ViewManagerList aViewMenegers = anApp->viewManagers();
1622             ViewManagerList::const_iterator it = aViewMenegers.begin();
1623             for( ; it != aViewMenegers.end(); it++) {
1624               SUIT_ViewManager* vm = *it;
1625               int nbSf = vm ? vm->getViewsCount() : 0;
1626               if(vm) {
1627                 QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1628                 for(int i = 0; i < nbSf; i++){
1629                   SUIT_ViewWindow *sf = aViews[i];
1630                   if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1631                     SMESH::RemoveActor(sf,anActor);
1632                   }
1633                 }
1634               }
1635             }
1636           }
1637             /** Remove an object from data structures **/
1638             SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1639             SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1640             if ( !aGroup->_is_nil() ) {                          // DELETE GROUP
1641               SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1642               aMesh->RemoveGroup( aGroup );
1643             }
1644             else if ( !aSubMesh->_is_nil() ) {                   // DELETE SUBMESH
1645               SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1646               aMesh->RemoveSubMesh( aSubMesh );
1647
1648               _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1649               if (aMeshSO)
1650                 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1651             }
1652             else {
1653               IObject = new SALOME_InteractiveObject
1654                 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1655               QString objType = CheckTypeObject(IObject);
1656               if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1657                 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1658                 aStudyBuilder->RemoveObjectWithChildren( SO );
1659               }
1660               else {// default action: remove SObject from the study
1661                 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1662                 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1663                 //op->start();
1664                 aStudyBuilder->RemoveObjectWithChildren( SO );
1665                 //op->finish();
1666               }
1667             }
1668           } /* listSO back loop */
1669         } /* IObject->hasEntry() */
1670       } /* more/next */
1671
1672     aStudyBuilder->CommitCommand();
1673
1674     /* Clear any previous selection */
1675     SALOME_ListIO l1;
1676     aSel->setSelectedObjects( l1 );
1677
1678     SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1679   }
1680 //}
1681
1682 extern "C" {
1683   SMESHGUI_EXPORT CAM_Module* createModule()
1684   {
1685     return new SMESHGUI();
1686   }
1687
1688   SMESHGUI_EXPORT  char* getModuleVersion() {
1689     return (char*)SMESH_VERSION_STR;
1690   }
1691 }
1692
1693 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1694
1695 //=============================================================================
1696 /*!
1697  *
1698  */
1699 //=============================================================================
1700 SMESHGUI::SMESHGUI() :
1701 SalomeApp_Module( "SMESH" ),
1702 LightApp_Module( "SMESH" )
1703 {
1704   if ( CORBA::is_nil( myComponentSMESH ) )
1705   {
1706     CORBA::Boolean anIsEmbeddedMode;
1707     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1708     MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1709
1710     //  0019923: EDF 765 SMESH : default values of hypothesis
1711     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1712     int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1713     myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1714     nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1715     myComponentSMESH->SetDefaultNbSegments( nbSeg );
1716   }
1717
1718   myActiveDialogBox = 0;
1719   myFilterLibraryDlg = 0;
1720   myState = -1;
1721   myDisplayer = 0;
1722
1723   myEventCallbackCommand = vtkCallbackCommand::New();
1724   myEventCallbackCommand->Delete();
1725   myEventCallbackCommand->SetClientData( this );
1726   myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1727   myPriority = 0.0;
1728
1729   SMESH::GetFilterManager();
1730   SMESH::GetPattern();
1731   SMESH::GetMeasurements();
1732
1733   /* load resources for all available meshers */
1734   SMESH::InitAvailableHypotheses();
1735 }
1736
1737 //=============================================================================
1738 /*!
1739  *
1740  */
1741 //=============================================================================
1742 SMESHGUI::~SMESHGUI()
1743 {
1744 #ifdef WITHGENERICOBJ
1745   SMESH::GetFilterManager()->UnRegister();
1746   SMESH::GetMeasurements()->UnRegister();
1747 #endif
1748   SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1749   SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1750 }
1751
1752 //=============================================================================
1753 /*!
1754  *
1755  */
1756 //=============================================================================
1757 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1758 {
1759   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1760   if( anApp )
1761     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1762   else
1763     return 0;
1764 }
1765
1766 //=============================================================================
1767 /*!
1768  *
1769  */
1770 //=============================================================================
1771 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1772 {
1773   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1774   if ( !resMgr )
1775     return false;
1776
1777   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
1778   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1779   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1780   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1781   return autoUpdate && !exceeded;
1782 }
1783
1784 //=============================================================================
1785 /*!
1786  *
1787  */
1788 //=============================================================================
1789 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1790 {
1791   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1792 }
1793
1794 //=============================================================================
1795 /*!
1796  *
1797  */
1798 //=============================================================================
1799 SMESHGUI* SMESHGUI::GetSMESHGUI()
1800 {
1801   SMESHGUI* smeshMod = 0;
1802   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1803   if ( app )
1804   {
1805     CAM_Module* module = app->module( "Mesh" );
1806     smeshMod = dynamic_cast<SMESHGUI*>( module );
1807   }
1808
1809   if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1810   {
1811     SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1812     if ( study )
1813     {
1814       _PTR(Study) aStudy = study->studyDS();
1815       if ( aStudy )
1816         GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
1817     }
1818   }
1819
1820   return smeshMod;
1821 }
1822
1823 extern "C"
1824 {
1825   Standard_EXPORT SMESHGUI* GetComponentGUI()
1826   {
1827     return SMESHGUI::GetSMESHGUI();
1828   }
1829 }
1830
1831 //=============================================================================
1832 /*!
1833  *
1834  */
1835 //=============================================================================
1836 void SMESHGUI::SetState(int aState)
1837 {
1838   myState = aState;
1839 }
1840
1841 //=============================================================================
1842 /*!
1843  *
1844  */
1845 //=============================================================================
1846 void SMESHGUI::ResetState()
1847 {
1848   myState = -1;
1849 }
1850
1851 //=============================================================================
1852 /*!
1853  *
1854  */
1855 //=============================================================================
1856 void SMESHGUI::EmitSignalDeactivateDialog()
1857 {
1858   emit SignalDeactivateActiveDialog();
1859 }
1860
1861 //=============================================================================
1862 /*!
1863  *
1864  */
1865 //=============================================================================
1866 void SMESHGUI::EmitSignalStudyFrameChanged()
1867 {
1868   emit SignalStudyFrameChanged();
1869 }
1870
1871 //=============================================================================
1872 /*!
1873  *
1874  */
1875 //=============================================================================
1876 void SMESHGUI::EmitSignalCloseAllDialogs()
1877 {
1878   emit SignalCloseAllDialogs();
1879 }
1880
1881 //=============================================================================
1882 /*!
1883  *
1884  */
1885 //=============================================================================
1886 void SMESHGUI::EmitSignalVisibilityChanged()
1887 {
1888   emit SignalVisibilityChanged();
1889 }
1890
1891 //=============================================================================
1892 /*!
1893  *
1894  */
1895 //=============================================================================
1896 QDialog *SMESHGUI::GetActiveDialogBox()
1897 {
1898   return myActiveDialogBox;
1899 }
1900
1901 //=============================================================================
1902 /*!
1903  *
1904  */
1905 //=============================================================================
1906 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
1907 {
1908   myActiveDialogBox = (QDialog *) aDlg;
1909   return;
1910 }
1911
1912 //=============================================================================
1913 /*!
1914  *
1915  */
1916 //=============================================================================
1917 SUIT_Desktop* SMESHGUI::desktop()
1918 {
1919   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1920   if( app )
1921     return app->desktop();
1922   else
1923     return 0;
1924 }
1925
1926 //=============================================================================
1927 /*!
1928  *
1929  */
1930 //=============================================================================
1931 SalomeApp_Study* SMESHGUI::activeStudy()
1932 {
1933   SUIT_Application* app = SUIT_Session::session()->activeApplication();
1934   if( app )
1935     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1936   else
1937     return NULL;
1938 }
1939
1940 //=============================================================================
1941 /*!
1942  *
1943  */
1944 //=============================================================================
1945 void SMESHGUI::Modified( bool theIsUpdateActions )
1946 {
1947   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
1948     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
1949       appStudy->Modified();
1950       if( theIsUpdateActions )
1951         app->updateActions();
1952     }
1953   }
1954 }
1955
1956 //=============================================================================
1957 /*!
1958  *
1959  */
1960 //=============================================================================
1961 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
1962 {
1963   /* Here the position is on the bottom right corner - 10 */
1964   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
1965   aDlg->adjustSize();
1966   SUIT_Desktop *PP = desktop();
1967   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
1968   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
1969   return true;
1970 }
1971
1972 //=============================================================================
1973 /*!
1974  *
1975  */
1976 //=============================================================================
1977 static int isStudyLocked(_PTR(Study) theStudy){
1978   return theStudy->GetProperties()->IsLocked();
1979 }
1980
1981 static bool checkLock(_PTR(Study) theStudy) {
1982   if (isStudyLocked(theStudy)) {
1983     SUIT_MessageBox::warning( SMESHGUI::desktop(),
1984                               QObject::tr("WRN_WARNING"),
1985                               QObject::tr("WRN_STUDY_LOCKED") );
1986     return true;
1987   }
1988   return false;
1989 }
1990
1991 //=======================================================================
1992 //function : CheckActiveStudyLocked
1993 //purpose  :
1994 //=======================================================================
1995
1996 bool SMESHGUI::isActiveStudyLocked()
1997 {
1998   _PTR(Study) aStudy = activeStudy()->studyDS();
1999   return checkLock( aStudy );
2000 }
2001
2002 //=============================================================================
2003 /*!
2004  *
2005  */
2006 //=============================================================================
2007 bool SMESHGUI::OnGUIEvent( int theCommandID )
2008 {
2009   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2010   if( !anApp )
2011     return false;
2012
2013   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2014   SUIT_ResourceMgr* mgr = resourceMgr();
2015   if( !mgr )
2016     return false;
2017
2018   if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2019     GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2020   }
2021
2022   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2023   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2024
2025   //QAction* act = action( theCommandID );
2026
2027   switch (theCommandID) {
2028   case 33:                                      // DELETE
2029     if(checkLock(aStudy)) break;
2030     OnEditDelete();
2031     break;
2032
2033   case 116:
2034   case 115:
2035   case 117:
2036   case 113:
2037   case 112:
2038   case 111:                                     // IMPORT
2039     {
2040       if(checkLock(aStudy)) break;
2041       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2042       break;
2043     }
2044
2045   case 150:    //MED FILE INFORMATION
2046     {
2047       SALOME_ListIO selected;
2048       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2049       if( aSel )
2050         aSel->selectedObjects( selected );
2051       if( selected.Extent() )
2052       {
2053         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2054         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2055         if ( !aMesh->_is_nil() )
2056         {
2057           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2058           dlg.exec();
2059         }
2060       }
2061       break;
2062     }
2063
2064   case 122:                                     // EXPORT MED
2065   case 121:
2066   case 123:
2067   case 124:
2068   case 125:
2069   case 126:
2070   case 140:
2071   case 141:
2072   case 142:
2073   case 143:
2074   case 144:
2075   case 145:
2076     {
2077       ::ExportMeshToFile(theCommandID);
2078       break;
2079     }
2080
2081   case 200:                                     // SCALAR BAR
2082     {
2083       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2084       SALOME_ListIO selected;
2085       if( aSel )
2086         aSel->selectedObjects( selected );
2087
2088       if( selected.Extent() ) {
2089         Handle(SALOME_InteractiveObject) anIO = selected.First();
2090         if( anIO->hasEntry() ) {
2091           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2092             anActor->SetControlMode( SMESH_Actor::eNone );
2093 #ifndef DISABLE_PLOT2DVIEWER
2094             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2095 #endif
2096           }
2097         }
2098       }
2099       break;
2100     }
2101   case 201:
2102     {
2103       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2104       break;
2105     }
2106   case 2021:
2107     {
2108       // dump control distribution data to the text file
2109       ::SaveDistribution();
2110       break;
2111     }
2112
2113   case 2022:
2114     {
2115       // show/ distribution
2116       ::ShowDistribution();
2117       break;
2118     }
2119
2120 #ifndef DISABLE_PLOT2DVIEWER
2121   case 2023:
2122     {
2123       // plot distribution
2124       ::PlotDistribution();
2125       break;
2126     }
2127 #endif
2128
2129     // Auto-color
2130   case 1136:
2131     ::AutoColor();
2132   break;
2133
2134   case 1137:
2135     ::DisableAutoColor();
2136   break;
2137
2138   case 1134: // Clipping
2139   case 1133: // Tranparency
2140   case 1132: // Colors / Size
2141
2142     // Display Mode
2143   case 215: // Nodes
2144   case 213: // Nodes
2145   case 212: // Nodes
2146   case 211: // Nodes
2147     ::SetDisplayMode(theCommandID, myMarkerMap);
2148   break;
2149
2150   //2D quadratic representation
2151   case 231:
2152   case 232:
2153     ::SetDisplayMode(theCommandID, myMarkerMap);
2154   break;
2155
2156   // Display Entity
2157   case 216: // 0D elements
2158   case 217: // Edges
2159   case 218: // Faces
2160   case 219: // Volumes
2161   case 220: // All Entity
2162     ::SetDisplayEntity(theCommandID);
2163   break;
2164
2165   case 221: // Orientation of faces
2166     {
2167       LightApp_SelectionMgr* mgr = selectionMgr();
2168       SALOME_ListIO selected; mgr->selectedObjects( selected );
2169
2170       SALOME_ListIteratorOfListIO it(selected);
2171       for( ; it.More(); it.Next()) {
2172         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2173         if(anIObject->hasEntry()) {
2174           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2175             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2176           }
2177         }
2178       }
2179       break;
2180     }
2181
2182   case 214:                                     // UPDATE
2183     {
2184       if(checkLock(aStudy)) break;
2185       try {
2186 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2187         OCC_CATCH_SIGNALS;
2188 #endif
2189         SMESH::UpdateView();
2190       }
2191       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2192         SMESH::OnVisuException();
2193       }
2194       catch (...) { // PAL16774 (Crash after display of many groups)
2195         SMESH::OnVisuException();
2196       }
2197
2198       SALOME_ListIO l;
2199       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2200       aSel->selectedObjects( l );
2201       aSel->setSelectedObjects( l );
2202       break;
2203     }
2204
2205   case 300:                                     // ERASE
2206   case 301:                                     // DISPLAY
2207   case 302:                                     // DISPLAY ONLY
2208     {
2209       SMESH::EDisplaing anAction;
2210       switch (theCommandID) {
2211       case 300: anAction = SMESH::eErase; break;
2212       case 301: anAction = SMESH::eDisplay; break;
2213       case 302: anAction = SMESH::eDisplayOnly; break;
2214       }
2215
2216       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2217       SALOME_ListIO sel_objects, to_process;
2218       if (aSel)
2219         aSel->selectedObjects( sel_objects );
2220
2221       if( theCommandID==302 )
2222       {
2223         MESSAGE("anAction = SMESH::eDisplayOnly");
2224         startOperation( myEraseAll );
2225       }
2226
2227       extractContainers( sel_objects, to_process );
2228
2229       try {
2230 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2231         OCC_CATCH_SIGNALS;
2232 #endif
2233         if (vtkwnd) {
2234           SALOME_ListIteratorOfListIO It( to_process );
2235           for ( ; It.More(); It.Next()) {
2236                 MESSAGE("---");
2237             Handle(SALOME_InteractiveObject) IOS = It.Value();
2238             if (IOS->hasEntry()) {
2239                 MESSAGE("---");
2240               if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2241                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2242                 break; // PAL16774 (Crash after display of many groups)
2243               }
2244               if (anAction == SMESH::eDisplayOnly)
2245               {
2246                 MESSAGE("anAction = SMESH::eDisplayOnly");
2247                 anAction = SMESH::eDisplay;
2248               }
2249             }
2250           }
2251         }
2252
2253         // PAL13338 + PAL15161 -->
2254         if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2255                 MESSAGE("anAction = SMESH::eDisplayOnly");
2256           SMESH::UpdateView();
2257           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2258         }
2259         // PAL13338 + PAL15161 <--
2260       }
2261       catch (...) { // PAL16774 (Crash after display of many groups)
2262         SMESH::OnVisuException();
2263       }
2264
2265       if (anAction == SMESH::eErase) {
2266         MESSAGE("anAction == SMESH::eErase");
2267         SALOME_ListIO l1;
2268         aSel->setSelectedObjects( l1 );
2269       }
2270       else
2271         aSel->setSelectedObjects( to_process );
2272
2273       break;
2274     }
2275
2276   case 4000:                                    // NODES
2277     {
2278       if(checkLock(aStudy)) break;
2279
2280       if ( vtkwnd ) {
2281         EmitSignalDeactivateDialog();
2282
2283         ( new SMESHGUI_NodesDlg( this ) )->show();
2284       }
2285       else {
2286         SUIT_MessageBox::warning(desktop(),
2287                                  tr("SMESH_WRN_WARNING"),
2288                                  tr("SMESH_WRN_VIEWER_VTK"));
2289       }
2290       break;
2291     }
2292
2293   case 2151:  // FILTER
2294   {
2295     if ( vtkwnd )
2296     {
2297       EmitSignalDeactivateDialog();
2298       ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2299     }
2300     break;
2301   }
2302
2303   case 701:                                     // COMPUTE MESH
2304   case 711:                                     // PRECOMPUTE MESH
2305   case 712:                                     // EVALUATE MESH
2306   case 713:                                     // MESH ORDER
2307     {
2308       if (checkLock(aStudy)) break;
2309       startOperation( theCommandID );
2310     }
2311     break;
2312
2313   case 702: // Create mesh
2314   case 703: // Create sub-mesh
2315   case 704: // Edit mesh/sub-mesh
2316     startOperation( theCommandID );
2317     break;
2318   case 705: // copy mesh
2319     {
2320       if (checkLock(aStudy)) break;
2321       EmitSignalDeactivateDialog();
2322       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2323     }
2324     break;
2325   case 710: // Build compound mesh
2326     {
2327       if (checkLock(aStudy)) break;
2328       EmitSignalDeactivateDialog();
2329       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2330     }
2331     break;
2332
2333   case 407: // DIAGONAL INVERSION
2334   case 408: // Delete diagonal
2335     {
2336       if ( !vtkwnd )
2337       {
2338         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2339                                   tr( "NOT_A_VTK_VIEWER" ) );
2340         break;
2341       }
2342
2343       if ( checkLock( aStudy ) )
2344         break;
2345
2346       /*Standard_Boolean aRes;
2347       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2348       if ( aMesh->_is_nil() )
2349       {
2350         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2351           tr( "SMESH_BAD_SELECTION" ) );
2352         break;
2353       }
2354       */
2355       EmitSignalDeactivateDialog();
2356       if ( theCommandID == 407 )
2357         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2358       else
2359         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2360       break;
2361     }
2362   case 409: // Change orientation
2363   case 410: // Union of triangles
2364   case 411: // Cutting of quadrangles
2365   case 419: // Splitting volumes into tetrahedra
2366     {
2367       if ( !vtkwnd )
2368       {
2369         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2370                                   tr( "NOT_A_VTK_VIEWER" ) );
2371         break;
2372       }
2373
2374       if ( checkLock( aStudy ) )
2375         break;
2376
2377       EmitSignalDeactivateDialog();
2378       SMESHGUI_MultiEditDlg* aDlg = NULL;
2379       if ( theCommandID == 409 )
2380         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2381       else if ( theCommandID == 410 )
2382         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2383       else if ( theCommandID == 419 )
2384         aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2385       else
2386         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2387
2388       aDlg->show();
2389       break;
2390     }
2391   case 412: // Smoothing
2392     {
2393       if(checkLock(aStudy)) break;
2394       if( vtkwnd ) {
2395         EmitSignalDeactivateDialog();
2396         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2397       }
2398       else {
2399         SUIT_MessageBox::warning(desktop(),
2400                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2401       }
2402       break;
2403     }
2404   case 413: // Extrusion
2405     {
2406       if (checkLock(aStudy)) break;
2407       if (vtkwnd) {
2408         EmitSignalDeactivateDialog();
2409         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2410       } else {
2411         SUIT_MessageBox::warning(desktop(),
2412                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2413       }
2414       break;
2415     }
2416   case 414: // Revolution
2417     {
2418       if(checkLock(aStudy)) break;
2419       if( vtkwnd ) {
2420         EmitSignalDeactivateDialog();
2421         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2422       }
2423       else {
2424         SUIT_MessageBox::warning(desktop(),
2425                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2426       }
2427       break;
2428     }
2429   case 415: // Pattern mapping
2430     {
2431       if ( checkLock( aStudy ) )
2432         break;
2433       if ( vtkwnd )
2434       {
2435         EmitSignalDeactivateDialog();
2436         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2437       }
2438       else {
2439         SUIT_MessageBox::warning(desktop(),
2440                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2441       }
2442       break;
2443     }
2444   case 416: // Extrusion along a path
2445     {
2446       if (checkLock(aStudy)) break;
2447       if (vtkwnd) {
2448         EmitSignalDeactivateDialog();
2449         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2450       } else {
2451         SUIT_MessageBox::warning(desktop(),
2452                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2453       }
2454       break;
2455     }
2456   case 417: // Convert mesh to quadratic
2457     {
2458     startOperation( 417 );
2459       /*      if (checkLock(aStudy)) break;
2460       if (vtkwnd) {
2461         EmitSignalDeactivateDialog();
2462         new SMESHGUI_ConvToQuadDlg();
2463       } else {
2464         SUIT_MessageBox::warning(desktop(),
2465                                tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2466                                }*/
2467       break;
2468     }
2469   case 418: // create 2D mesh from 3D
2470     {
2471       startOperation( 418 );
2472       break;
2473     }
2474   case 806:                                     // CREATE GEO GROUP
2475     {
2476       startOperation( 806 );
2477       break;
2478     }
2479   case 801:                                     // CREATE GROUP
2480     {
2481       if ( !vtkwnd )
2482       {
2483         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2484                                   tr( "NOT_A_VTK_VIEWER" ) );
2485         break;
2486       }
2487
2488       if(checkLock(aStudy)) break;
2489       EmitSignalDeactivateDialog();
2490       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2491
2492       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2493       SALOME_ListIO selected;
2494       if( aSel )
2495         aSel->selectedObjects( selected );
2496
2497       int nbSel = selected.Extent();
2498       if (nbSel == 1) {
2499         // check if mesh is selected
2500         aMesh = SMESH::GetMeshByIO( selected.First() );
2501       }
2502       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2503       aDlg->show();
2504       break;
2505     }
2506
2507   case 802:                                     // CONSTRUCT GROUP
2508     {
2509       if ( !vtkwnd )
2510       {
2511         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2512                                   tr( "NOT_A_VTK_VIEWER" ) );
2513         break;
2514       }
2515
2516       if(checkLock(aStudy)) break;
2517       EmitSignalDeactivateDialog();
2518
2519       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2520       SALOME_ListIO selected;
2521       if( aSel )
2522         aSel->selectedObjects( selected );
2523
2524       int nbSel = selected.Extent();
2525       if (nbSel == 1) {
2526         // check if submesh is selected
2527         Handle(SALOME_InteractiveObject) IObject = selected.First();
2528         if (IObject->hasEntry()) {
2529           _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2530           if( aSObj ) {
2531             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2532             if (!aSubMesh->_is_nil()) {
2533               try {
2534                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2535                 // get submesh elements list by types
2536                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2537                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2538                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2539                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2540                 // create group for each type o elements
2541                 QString aName = IObject->getName();
2542                 QStringList anEntryList;
2543                 if (aNodes->length() > 0) {
2544                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2545                   aGroup->Add(aNodes.inout());
2546                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2547                     anEntryList.append( aSObject->GetID().c_str() );
2548                 }
2549                 if (aEdges->length() > 0) {
2550                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2551                   aGroup->Add(aEdges.inout());
2552                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2553                     anEntryList.append( aSObject->GetID().c_str() );
2554                 }
2555                 if (aFaces->length() > 0) {
2556                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2557                   aGroup->Add(aFaces.inout());
2558                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2559                     anEntryList.append( aSObject->GetID().c_str() );
2560                 }
2561                 if (aVolumes->length() > 0) {
2562                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2563                   aGroup->Add(aVolumes.inout());
2564                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2565                     anEntryList.append( aSObject->GetID().c_str() );
2566                 }
2567                 updateObjBrowser();
2568                 anApp->browseObjects( anEntryList );
2569               }
2570               catch(const SALOME::SALOME_Exception & S_ex){
2571                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2572               }
2573             }
2574           }
2575         }
2576       }
2577       else if(nbSel==0) {
2578         SUIT_MessageBox::warning(desktop(),
2579                                  tr("SMESH_WRN_WARNING"),
2580                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2581       }
2582       break;
2583     }
2584
2585   case 803:                                     // EDIT GROUP
2586     {
2587       if ( !vtkwnd )
2588       {
2589         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2590                                   tr( "NOT_A_VTK_VIEWER" ) );
2591         break;
2592       }
2593
2594       if(checkLock(aStudy)) break;
2595       EmitSignalDeactivateDialog();
2596
2597       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2598       SALOME_ListIO selected;
2599       if( aSel )
2600         aSel->selectedObjects( selected );
2601
2602       SALOME_ListIteratorOfListIO It (selected);
2603       int nbSelectedGroups = 0;
2604       for ( ; It.More(); It.Next() )
2605       {
2606         SMESH::SMESH_GroupBase_var aGroup =
2607           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2608         if (!aGroup->_is_nil()) {
2609           nbSelectedGroups++;
2610           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2611           aDlg->show();
2612         }
2613       }
2614       if (nbSelectedGroups == 0)
2615         {
2616           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2617           aDlg->show();
2618         }
2619       break;
2620     }
2621
2622   case 804:                                     // Add elements to group
2623     {
2624       if(checkLock(aStudy)) break;
2625       if (myState == 800) {
2626         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2627         if (aDlg) aDlg->onAdd();
2628       }
2629       break;
2630     }
2631
2632   case 805:                                     // Remove elements from group
2633     {
2634       if(checkLock(aStudy)) break;
2635       if (myState == 800) {
2636         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2637         if (aDlg) aDlg->onRemove();
2638       }
2639       break;
2640     }
2641
2642   case 815:                                     // Edit GEOM GROUP as standalone
2643     {
2644       if ( !vtkwnd )
2645       {
2646         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2647                                   tr( "NOT_A_VTK_VIEWER" ) );
2648         break;
2649       }
2650
2651       if(checkLock(aStudy)) break;
2652       EmitSignalDeactivateDialog();
2653
2654       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2655       SALOME_ListIO selected;
2656       if( aSel )
2657         aSel->selectedObjects( selected );
2658
2659       SALOME_ListIteratorOfListIO It (selected);
2660       for ( ; It.More(); It.Next() )
2661       {
2662         SMESH::SMESH_GroupOnGeom_var aGroup =
2663           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2664         if (!aGroup->_is_nil()) {
2665           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2666           aDlg->show();
2667         }
2668         else
2669         {
2670           SMESH::SMESH_GroupOnFilter_var aGroup =
2671             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2672           if (!aGroup->_is_nil()) {
2673             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2674             aDlg->show();
2675           }
2676         }
2677       }
2678       break;
2679     }
2680
2681     case 810: // Union Groups
2682     case 811: // Intersect groups
2683     case 812: // Cut groups
2684     {
2685       if ( !vtkwnd )
2686       {
2687         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2688                                   tr( "NOT_A_VTK_VIEWER" ) );
2689         break;
2690       }
2691
2692       if ( checkLock( aStudy ) )
2693         break;
2694
2695       EmitSignalDeactivateDialog();
2696
2697       SMESHGUI_GroupOpDlg* aDlg = 0;
2698       if ( theCommandID == 810 )
2699         aDlg = new SMESHGUI_UnionGroupsDlg( this );
2700       else if ( theCommandID == 811 )
2701         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2702       else
2703         aDlg = new SMESHGUI_CutGroupsDlg( this );
2704
2705       aDlg->show();
2706
2707       break;
2708     }
2709
2710     case 814: // Create groups of entities from existing groups of superior dimensions
2711     {
2712       if ( checkLock( aStudy ) )
2713         break;
2714
2715       EmitSignalDeactivateDialog();
2716       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2717       aDlg->show();
2718
2719       break;
2720     }
2721
2722     case 813: // Delete groups with their contents
2723     {
2724       if ( !vtkwnd )
2725       {
2726         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2727                                   tr( "NOT_A_VTK_VIEWER" ) );
2728         break;
2729       }
2730
2731       if ( checkLock( aStudy ) )
2732         break;
2733
2734       EmitSignalDeactivateDialog();
2735
2736       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2737       break;
2738     }
2739
2740   case 900:                                     // MESH INFOS
2741   case 903:                                     // WHAT IS
2742     {
2743       int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2744       EmitSignalDeactivateDialog();
2745       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2746       SALOME_ListIO selected;
2747       if( aSel )
2748         aSel->selectedObjects( selected );
2749
2750       if ( selected.Extent() > 1 ) { // a dlg for each IO
2751         SALOME_ListIteratorOfListIO It( selected );
2752         for ( ; It.More(); It.Next() ) {
2753           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2754           dlg->showInfo( It.Value() );
2755           dlg->show();
2756         }
2757       }
2758       else {
2759         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2760         dlg->show();
2761       }
2762       break;
2763     }
2764
2765   case 904:                                     // FIND ELEM
2766     {
2767       startOperation( theCommandID );
2768       break;
2769     }
2770
2771   case 1100:                                    // EDIT HYPOTHESIS
2772     {
2773       if(checkLock(aStudy)) break;
2774
2775       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2776       SALOME_ListIO selected;
2777       if( aSel )
2778         aSel->selectedObjects( selected );
2779
2780       int nbSel = selected.Extent();
2781
2782       if (nbSel == 1) {
2783         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2784         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2785
2786         /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2787         /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects                   */
2788         /* Warning : however by internal mechanism all subMeshes icons are changed !                     */
2789         if ( !aHypothesis->_is_nil() )
2790         {
2791           // BUG 0020378
2792           //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2793           SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2794           if (aCreator) {
2795             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2796           }
2797           else
2798           {
2799             // report error
2800           }
2801         }
2802       }
2803       break;
2804     }
2805   case 1102:                                    // REMOVE HYPOTHESIS / ALGORITHMS
2806     {
2807       if(checkLock(aStudy)) break;
2808       SUIT_OverrideCursor wc;
2809
2810       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2811       SALOME_ListIO selected;
2812       if( aSel )
2813         aSel->selectedObjects( selected, QString::null, false );
2814
2815       SALOME_ListIteratorOfListIO It(selected);
2816       for (int i = 0; It.More(); It.Next(), i++) {
2817         Handle(SALOME_InteractiveObject) IObject = It.Value();
2818         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2819       }
2820       SALOME_ListIO l1;
2821       aSel->setSelectedObjects( l1 );
2822       updateObjBrowser();
2823       break;
2824     }
2825
2826   case 4009:                                    // ELEM0D
2827   case 4010:                                    // EDGE
2828   case 4021:                                    // TRIANGLE
2829   case 4022:                                    // QUAD
2830   case 4023:                                    // POLYGON
2831   case 4031:                                    // TETRA
2832   case 4032:                                    // HEXA
2833   case 4133:                                    // PENTA
2834   case 4134:                                    // PYRAMID
2835   case 4135:                                    // OCTA12
2836     {
2837       if(checkLock(aStudy)) break;
2838       if ( vtkwnd ) {
2839         EmitSignalDeactivateDialog();
2840         SMDSAbs_EntityType type = SMDSEntity_Edge;
2841         switch (theCommandID) {
2842         case 4009:
2843           type = SMDSEntity_0D; break;
2844         case 4021:
2845           type = SMDSEntity_Triangle; break;
2846         case 4022:
2847           type = SMDSEntity_Quadrangle; break;
2848         case 4031:
2849           type = SMDSEntity_Tetra; break;
2850         case 4023:
2851           type = SMDSEntity_Polygon; break;
2852         case 4032:
2853           type = SMDSEntity_Hexa; break;
2854         case 4133:
2855           type = SMDSEntity_Penta; break;
2856         case 4134:
2857           type = SMDSEntity_Pyramid; break;
2858         case 4135:
2859           type = SMDSEntity_Hexagonal_Prism; break;
2860         default:;
2861         }
2862         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
2863       }
2864       else {
2865         SUIT_MessageBox::warning(desktop(),
2866                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2867       }
2868       break;
2869     }
2870   case 4033:                                    // POLYHEDRON
2871     {
2872       if(checkLock(aStudy)) break;
2873       if ( vtkwnd ) {
2874         EmitSignalDeactivateDialog();
2875         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
2876       }
2877       else {
2878         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2879                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2880       }
2881       break;
2882     }
2883   case 4034:     // QUADRATIC EDGE
2884   case 4035:     // QUADRATIC TRIANGLE
2885   case 4036:     // QUADRATIC QUADRANGLE
2886   case 4136:     // BIQUADRATIC QUADRANGLE
2887   case 4037:     // QUADRATIC TETRAHEDRON
2888   case 4038:     // QUADRATIC PYRAMID
2889   case 4039:     // QUADRATIC PENTAHEDRON
2890   case 4040:     // QUADRATIC HEXAHEDRON
2891   case 4140:     // TRIQUADRATIC HEXAHEDRON
2892     {
2893       if(checkLock(aStudy)) break;
2894       if ( vtkwnd ) {
2895         EmitSignalDeactivateDialog();
2896         SMDSAbs_EntityType type;
2897
2898         switch (theCommandID) {
2899         case 4034:
2900           type = SMDSEntity_Quad_Edge; break;
2901         case 4035:
2902           type = SMDSEntity_Quad_Triangle; break;
2903         case 4036:
2904           type = SMDSEntity_Quad_Quadrangle; break;
2905         case 4136:
2906           type = SMDSEntity_BiQuad_Quadrangle; break;
2907         case 4037:
2908           type = SMDSEntity_Quad_Tetra; break;
2909         case 4038:
2910           type = SMDSEntity_Quad_Pyramid; break;
2911         case 4039:
2912           type = SMDSEntity_Quad_Penta; break;
2913         case 4040:
2914           type = SMDSEntity_Quad_Hexa;
2915         case 4140:
2916           type = SMDSEntity_TriQuad_Hexa;
2917           break;
2918         default:;
2919         }
2920          ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
2921       }
2922       else {
2923         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2924                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2925       }
2926       break;
2927     }
2928   case 4041:                                    // REMOVES NODES
2929     {
2930       if(checkLock(aStudy)) break;
2931       if ( vtkwnd ) {
2932         EmitSignalDeactivateDialog();
2933         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
2934       }
2935       else {
2936         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2937                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2938       }
2939       break;
2940     }
2941   case 4042:                                    // REMOVES ELEMENTS
2942     {
2943       if(checkLock(aStudy)) break;
2944       if( vtkwnd ) {
2945         EmitSignalDeactivateDialog();
2946         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
2947       }
2948       else
2949         {
2950           SUIT_MessageBox::warning(SMESHGUI::desktop(),
2951                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2952         }
2953       break;
2954     }
2955   case 4043: {                                // CLEAR_MESH
2956
2957     if(checkLock(aStudy)) break;
2958
2959     SALOME_ListIO selected;
2960     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2961       aSel->selectedObjects( selected );
2962
2963     SUIT_OverrideCursor wc;
2964     SALOME_ListIteratorOfListIO It (selected);
2965     for ( ; It.More(); It.Next() )
2966     {
2967       Handle(SALOME_InteractiveObject) IOS = It.Value();
2968       SMESH::SMESH_Mesh_var aMesh =
2969         SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
2970       if ( aMesh->_is_nil()) continue;
2971       try {
2972         SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
2973         aMesh->Clear();
2974         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
2975         SMESH::ModifiedMesh( aMeshSObj, false, true);
2976         // hide groups and submeshes
2977         _PTR(ChildIterator) anIter =
2978           SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
2979         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
2980         {
2981           _PTR(SObject) so = anIter->Value();
2982           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
2983         }
2984       }
2985       catch (const SALOME::SALOME_Exception& S_ex){
2986         wc.suspend();
2987         SalomeApp_Tools::QtCatchCorbaException(S_ex);
2988         wc.resume();
2989       }
2990     }
2991     SMESH::UpdateView();
2992     updateObjBrowser();
2993     break;
2994   }
2995   case 4044:                                     // REMOVE ORPHAN NODES
2996     {
2997       if(checkLock(aStudy)) break;
2998       SALOME_ListIO selected;
2999       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3000         aSel->selectedObjects( selected );
3001       if ( selected.Extent() == 1 ) {
3002         Handle(SALOME_InteractiveObject) anIO = selected.First();
3003         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3004         if ( !aMesh->_is_nil() ) {
3005           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3006                                                     tr( "SMESH_WARNING" ),
3007                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3008                                                     SUIT_MessageBox::Yes |
3009                                                     SUIT_MessageBox::No,
3010                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3011           if( confirm ) {
3012             try {
3013               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3014               int removed = aMeshEditor->RemoveOrphanNodes();
3015               SUIT_MessageBox::information(SMESHGUI::desktop(),
3016                                            tr("SMESH_INFORMATION"),
3017                                            tr("NB_NODES_REMOVED").arg(removed));
3018               if ( removed > 0 ) {
3019                 SMESH::UpdateView();
3020                 SMESHGUI::Modified();
3021               }
3022             }
3023             catch (const SALOME::SALOME_Exception& S_ex) {
3024               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3025             }
3026             catch (...) {
3027             }
3028           }
3029         }
3030       }
3031       break;
3032     }
3033   case 4051:                                    // RENUMBERING NODES
3034     {
3035       if(checkLock(aStudy)) break;
3036       if( vtkwnd ) {
3037         EmitSignalDeactivateDialog();
3038         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3039       }
3040       else
3041         {
3042           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3043                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3044         }
3045       break;
3046     }
3047   case 4052:                                    // RENUMBERING ELEMENTS
3048     {
3049       if(checkLock(aStudy)) break;
3050       if ( vtkwnd ) {
3051         EmitSignalDeactivateDialog();
3052         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3053       }
3054       else
3055         {
3056           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3057                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3058         }
3059       break;
3060     }
3061   case 4061:                                   // TRANSLATION
3062     {
3063       if(checkLock(aStudy)) break;
3064       if ( vtkwnd ) {
3065         EmitSignalDeactivateDialog();
3066         ( new SMESHGUI_TranslationDlg( this ) )->show();
3067       }
3068       else {
3069         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3070                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3071       }
3072       break;
3073     }
3074   case 4062:                                   // ROTATION
3075     {
3076       if(checkLock(aStudy)) break;
3077       if( vtkwnd ) {
3078         EmitSignalDeactivateDialog();
3079         ( new SMESHGUI_RotationDlg( this ) )->show();
3080       }
3081       else {
3082         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3083                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3084       }
3085       break;
3086     }
3087   case 4063:                                   // SYMMETRY
3088     {
3089       if(checkLock(aStudy)) break;
3090       if(vtkwnd) {
3091         EmitSignalDeactivateDialog();
3092         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3093       }
3094       else {
3095         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3096                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3097       }
3098       break;
3099     }
3100   case 4064:                                   // SEWING
3101     {
3102       if(checkLock(aStudy)) break;
3103       if(vtkwnd) {
3104         EmitSignalDeactivateDialog();
3105         ( new SMESHGUI_SewingDlg( this ) )->show();
3106       }
3107       else {
3108         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3109                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3110       }
3111       break;
3112     }
3113   case 4065:                                   // MERGE NODES
3114     {
3115       if(checkLock(aStudy)) break;
3116       if(vtkwnd) {
3117         EmitSignalDeactivateDialog();
3118         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3119       }
3120       else {
3121         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3122                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3123       }
3124       break;
3125     }
3126   case 4066:                                   // MERGE EQUAL ELEMENTS
3127     {
3128       if (checkLock(aStudy)) break;
3129       if (vtkwnd) {
3130         EmitSignalDeactivateDialog();
3131         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3132       } else {
3133         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3134                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3135       }
3136       break;
3137     }
3138
3139   case 4067: // MAKE MESH PASS THROUGH POINT
3140     startOperation( 4067 );
3141     break;
3142
3143   case 4068: // SCALE
3144     {
3145       if(checkLock(aStudy)) break;
3146       if ( vtkwnd ) {
3147         EmitSignalDeactivateDialog();
3148         ( new SMESHGUI_ScaleDlg( this ) )->show();
3149       }
3150       else {
3151         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3152                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3153       }
3154       break;
3155     }
3156
3157   case 4069: // DUPLICATE NODES
3158     {
3159       if(checkLock(aStudy)) break;
3160       if ( vtkwnd ) {
3161         EmitSignalDeactivateDialog();
3162         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3163       }
3164       else {
3165         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3166                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3167       }
3168       break;
3169     }
3170
3171   case 5105: // Library of selection filters
3172   {
3173     static QList<int> aTypes;
3174     if ( aTypes.isEmpty() )
3175     {
3176       aTypes.append( SMESH::NODE );
3177       aTypes.append( SMESH::EDGE );
3178       aTypes.append( SMESH::FACE );
3179       aTypes.append( SMESH::VOLUME );
3180     }
3181     if (!myFilterLibraryDlg)
3182       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3183     else if (myFilterLibraryDlg->isHidden())
3184       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3185     myFilterLibraryDlg->raise();
3186   }
3187   break;
3188
3189   case 6017:                                    // CONTROLS
3190   case 6016:
3191   case 6015:
3192   case 6014:
3193   case 6013:
3194   case 6012:
3195   case 6011:
3196   case 6001:
3197   case 6018:
3198   case 6019:
3199   case 6002:
3200   case 6003:
3201   case 6004:
3202   case 6005:
3203   case 6009:
3204   case 6021:
3205   case 6022:
3206   case 6023:
3207   case 6024:
3208   case 6025:
3209   case 6026:
3210   case 6027:
3211   case 6028:
3212   case 6029:
3213   case 6030:
3214   case 6031:
3215     if ( vtkwnd ) {
3216
3217       LightApp_SelectionMgr* mgr = selectionMgr();
3218       SALOME_ListIO selected; mgr->selectedObjects( selected );
3219
3220       if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3221         _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3222         if ( SO ) {
3223           CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3224           SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( aObject );
3225           SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3226           SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( aObject );
3227           if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3228             ::Control( theCommandID );
3229             break;
3230           }
3231         }
3232       }
3233       SUIT_MessageBox::warning(desktop(),
3234                                tr( "SMESH_WRN_WARNING" ),
3235                                tr( "SMESH_BAD_SELECTION" ) );
3236       break;
3237     }
3238     else {
3239       SUIT_MessageBox::warning(desktop(),
3240                                tr( "SMESH_WRN_WARNING" ),
3241                                tr( "NOT_A_VTK_VIEWER" ) );
3242     }
3243     break;
3244   case 9010:
3245     {
3246       LightApp_SelectionMgr* mgr = selectionMgr();
3247       SALOME_ListIO selected; mgr->selectedObjects( selected );
3248
3249       SALOME_ListIteratorOfListIO it(selected);
3250       for( ; it.More(); it.Next()) {
3251         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3252         if(anIObject->hasEntry()) {
3253           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3254             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3255           }
3256         }
3257       }
3258       break;
3259     }
3260   case 9011:
3261     {
3262       LightApp_SelectionMgr* mgr = selectionMgr();
3263       SALOME_ListIO selected; mgr->selectedObjects( selected );
3264
3265       SALOME_ListIteratorOfListIO it(selected);
3266       for( ; it.More(); it.Next()) {
3267         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3268         if(anIObject->hasEntry())
3269           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3270             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3271           }
3272       }
3273       break;
3274     }
3275   case 501:
3276   case 502:
3277     {
3278       int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3279       EmitSignalDeactivateDialog();
3280       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3281       dlg->show();
3282       break;
3283     }
3284   }
3285
3286   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3287   //updateObjBrowser();
3288   return true;
3289 }
3290
3291 //=============================================================================
3292 /*!
3293  *
3294  */
3295 //=============================================================================
3296 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3297 {
3298   return false;
3299 }
3300
3301 //=============================================================================
3302 /*!
3303  *
3304  */
3305 //=============================================================================
3306 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3307 {
3308   return true;
3309 }
3310
3311 //=============================================================================
3312 /*!
3313  *
3314  */
3315 //=============================================================================
3316 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3317 {
3318   return true;
3319 }
3320
3321 //=============================================================================
3322 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3323  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3324  */
3325 //=============================================================================
3326 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3327                                   SUIT_ViewWindow* wnd )
3328 {
3329   if(theIO->hasEntry()){
3330     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3331     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3332   }
3333 }
3334
3335 //=======================================================================
3336 // function : createSMESHAction
3337 // purpose  :
3338 //=======================================================================
3339 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3340                                   const int key, const bool toggle, const QString& shortcutAction  )
3341 {
3342   QIcon icon;
3343   QWidget* parent = application()->desktop();
3344   SUIT_ResourceMgr* resMgr = resourceMgr();
3345   QPixmap pix;
3346   if ( !icon_id.isEmpty() )
3347     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3348   else
3349     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3350   if ( !pix.isNull() )
3351     icon = QIcon( pix );
3352
3353   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3354           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3355           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3356
3357   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3358                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3359 }
3360
3361 //=======================================================================
3362 // function : createPopupItem
3363 // purpose  :
3364 //=======================================================================
3365 void SMESHGUI::createPopupItem( const int id,
3366                                 const QString& clients,
3367                                 const QString& types,
3368                                 const QString& theRule,
3369                                 const int pId )
3370 {
3371   int parentId = pId;
3372   if( pId!=-1 )
3373     parentId = popupMgr()->actionId( action( pId ) );
3374
3375   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3376     popupMgr()->insert( action( id ), parentId, 0 );
3377
3378   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3379   QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3380   QString rule = "(%1) and (%2) and (%3)";
3381   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3382   if( clients.isEmpty() )
3383     rule = rule.arg( QString( "true" ) );
3384   else
3385     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3386   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3387   rule += theRule;
3388
3389   bool cont = myRules.contains( id );
3390   if( cont )
3391     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3392
3393   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3394   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3395 }
3396
3397 //=======================================================================
3398 // function : initialize
3399 // purpose  :
3400 //=======================================================================
3401 void SMESHGUI::initialize( CAM_Application* app )
3402 {
3403   SalomeApp_Module::initialize( app );
3404
3405 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3406 //   if ( mgr )
3407   /* Automatic Update flag */
3408 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3409
3410   // ----- create actions --------------
3411
3412   createSMESHAction(  111, "DAT", "", (Qt::CTRL+Qt::Key_B) );
3413   createSMESHAction(  112, "UNV", "", (Qt::CTRL+Qt::Key_U) );
3414   createSMESHAction(  113, "MED", "", (Qt::CTRL+Qt::Key_M) );
3415   createSMESHAction(  114, "NUM" );
3416   createSMESHAction(  115, "STL" );
3417   createSMESHAction(  116, "CGNS" );
3418   createSMESHAction(  117, "SAUV" );
3419   createSMESHAction(  121, "DAT" );
3420   createSMESHAction(  122, "MED" );
3421   createSMESHAction(  123, "UNV" );
3422   createSMESHAction(  140, "STL" );
3423   createSMESHAction(  142, "CGNS" );
3424   createSMESHAction(  144, "SAUV" );
3425   createSMESHAction(  124, "EXPORT_DAT" );
3426   createSMESHAction(  125, "EXPORT_MED" );
3427   createSMESHAction(  126, "EXPORT_UNV" );
3428   createSMESHAction(  141, "EXPORT_STL" );
3429   createSMESHAction(  143, "EXPORT_CGNS" );
3430   createSMESHAction(  145, "EXPORT_SAUV" );
3431   createSMESHAction(  150, "FILE_INFO" );
3432   createSMESHAction(   33, "DELETE",          "ICON_DELETE", Qt::Key_Delete );
3433   createSMESHAction( 5105, "SEL_FILTER_LIB" );
3434   createSMESHAction(  701, "COMPUTE",         "ICON_COMPUTE" );
3435   createSMESHAction(  702, "CREATE_MESH",     "ICON_DLG_INIT_MESH" );
3436   createSMESHAction(  703, "CREATE_SUBMESH",  "ICON_DLG_ADD_SUBMESH" );
3437   createSMESHAction(  704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3438   createSMESHAction(  705, "COPY_MESH",       "ICON_COPY_MESH" );
3439   createSMESHAction(  710, "BUILD_COMPOUND",  "ICON_BUILD_COMPOUND" );
3440   createSMESHAction(  711, "PRECOMPUTE",      "ICON_PRECOMPUTE" );
3441   createSMESHAction(  712, "EVALUATE",        "ICON_COMPUTE" );
3442   createSMESHAction(  713, "MESH_ORDER",      "ICON_COMPUTE" );
3443   createSMESHAction(  806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3444   createSMESHAction(  801, "CREATE_GROUP",    "ICON_CREATE_GROUP" );
3445   createSMESHAction(  802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3446   createSMESHAction(  803, "EDIT_GROUP",      "ICON_EDIT_GROUP" );
3447   createSMESHAction(  815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3448   createSMESHAction(  804, "ADD" );
3449   createSMESHAction(  805, "REMOVE" );
3450   createSMESHAction(  810, "UN_GROUP",        "ICON_UNION" );
3451   createSMESHAction(  811, "INT_GROUP",       "ICON_INTERSECT" );
3452   createSMESHAction(  812, "CUT_GROUP",       "ICON_CUT" );
3453   createSMESHAction(  814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3454   createSMESHAction(  813, "DEL_GROUP",       "ICON_DEL_GROUP" );
3455   createSMESHAction(  900, "ADV_INFO",        "ICON_ADV_INFO" );
3456   //createSMESHAction(  902, "STD_INFO",        "ICON_STD_INFO" );
3457   //createSMESHAction(  903, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3458   createSMESHAction(  904, "FIND_ELEM",       "ICON_FIND_ELEM" );
3459   createSMESHAction( 6001, "LENGTH",          "ICON_LENGTH",        0, true );
3460   createSMESHAction( 6002, "FREE_EDGE",       "ICON_FREE_EDGE",     0, true );
3461   createSMESHAction( 6021, "FREE_FACES",      "ICON_FREE_FACES",    0, true );
3462   createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D",  "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
3463   createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D",  "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
3464   createSMESHAction( 6024, "BARE_BORDER_VOLUME",     "ICON_BARE_BORDER_VOLUME",      0, true );
3465   createSMESHAction( 6025, "BARE_BORDER_FACE",       "ICON_BARE_BORDER_FACE",        0, true );
3466   createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3467   createSMESHAction( 6027, "OVER_CONSTRAINED_FACE",  "ICON_OVER_CONSTRAINED_FACE",   0, true );
3468   createSMESHAction( 6028, "EQUAL_NODE",      "ICON_EQUAL_NODE",    0, true );
3469   createSMESHAction( 6029, "EQUAL_EDGE",      "ICON_EQUAL_EDGE",    0, true );
3470   createSMESHAction( 6030, "EQUAL_FACE",      "ICON_EQUAL_FACE",    0, true );
3471   createSMESHAction( 6031, "EQUAL_VOLUME",    "ICON_EQUAL_VOLUME",  0, true );
3472   createSMESHAction( 6003, "FREE_BORDER",     "ICON_FREE_EDGE_2D",  0, true );
3473   createSMESHAction( 6004, "CONNECTION",      "ICON_CONNECTION",    0, true );
3474   createSMESHAction( 6005, "FREE_NODE",       "ICON_FREE_NODE",     0, true );
3475   createSMESHAction( 6011, "AREA",            "ICON_AREA",          0, true );
3476   createSMESHAction( 6012, "TAPER",           "ICON_TAPER",         0, true );
3477   createSMESHAction( 6013, "ASPECT",          "ICON_ASPECT",        0, true );
3478   createSMESHAction( 6014, "MIN_ANG",         "ICON_ANGLE",         0, true );
3479   createSMESHAction( 6015, "WARP",            "ICON_WARP",          0, true );
3480   createSMESHAction( 6016, "SKEW",            "ICON_SKEW",          0, true );
3481   createSMESHAction( 6017, "ASPECT_3D",       "ICON_ASPECT_3D",     0, true );
3482   createSMESHAction( 6018, "LENGTH_2D",       "ICON_LENGTH_2D",     0, true );
3483   createSMESHAction( 6019, "CONNECTION_2D",   "ICON_CONNECTION_2D", 0, true );
3484   createSMESHAction( 6009, "VOLUME_3D",       "ICON_VOLUME_3D",     0, true );
3485   createSMESHAction( 4000, "NODE",            "ICON_DLG_NODE" );
3486   createSMESHAction( 4009, "ELEM0D",          "ICON_DLG_ELEM0D" );
3487   createSMESHAction( 4010, "EDGE",            "ICON_DLG_EDGE" );
3488   createSMESHAction( 4021, "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3489   createSMESHAction( 4022, "QUAD",            "ICON_DLG_QUADRANGLE" );
3490   createSMESHAction( 4023, "POLYGON",         "ICON_DLG_POLYGON" );
3491   createSMESHAction( 4031, "TETRA",           "ICON_DLG_TETRAS" );
3492   createSMESHAction( 4032, "HEXA",            "ICON_DLG_HEXAS" );
3493   createSMESHAction( 4133, "PENTA",           "ICON_DLG_PENTA" );
3494   createSMESHAction( 4134, "PYRAMID",         "ICON_DLG_PYRAMID" );
3495   createSMESHAction( 4135, "OCTA",            "ICON_DLG_OCTA" );
3496   createSMESHAction( 4033, "POLYHEDRON",              "ICON_DLG_POLYHEDRON" );
3497   createSMESHAction( 4034, "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
3498   createSMESHAction( 4035, "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
3499   createSMESHAction( 4036, "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
3500   createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3501   createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3502   createSMESHAction( 4038, "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
3503   createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3504   createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3505   createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3506   createSMESHAction( 4041, "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
3507   createSMESHAction( 4042, "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
3508   createSMESHAction( 4044, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
3509   createSMESHAction( 4043, "CLEAR_MESH"    ,  "ICON_CLEAR_MESH" );
3510   createSMESHAction( 4051, "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
3511   createSMESHAction( 4052, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
3512   createSMESHAction( 4061, "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
3513   createSMESHAction( 4062, "ROT",             "ICON_DLG_MESH_ROTATION" );
3514   createSMESHAction( 4063, "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
3515   createSMESHAction( 4064, "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
3516   createSMESHAction( 4065, "MERGE",           "ICON_SMESH_MERGE_NODES" );
3517   createSMESHAction( 4066, "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
3518   createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3519   createSMESHAction( 4068, "SCALE",           "ICON_DLG_MESH_SCALE" );
3520   createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3521   createSMESHAction(  407, "INV",             "ICON_DLG_MESH_DIAGONAL" );
3522   createSMESHAction(  408, "UNION2",          "ICON_UNION2TRI" );
3523   createSMESHAction(  409, "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
3524   createSMESHAction(  410, "UNION",           "ICON_UNIONTRI" );
3525   createSMESHAction(  411, "CUT",             "ICON_CUTQUAD" );
3526   createSMESHAction(  412, "SMOOTH",          "ICON_DLG_SMOOTHING" );
3527   createSMESHAction(  413, "EXTRUSION",       "ICON_EXTRUSION" );
3528   createSMESHAction(  414, "REVOLUTION",      "ICON_REVOLUTION" );
3529   createSMESHAction(  415, "MAP",             "ICON_MAP" );
3530   createSMESHAction(  416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3531   createSMESHAction(  417, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
3532   createSMESHAction(  418, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
3533   createSMESHAction(  419, "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
3534   createSMESHAction(  200, "RESET" );
3535   createSMESHAction(  201, "SCALAR_BAR_PROP" );
3536   createSMESHAction(  2021, "SAVE_DISTRIBUTION" );
3537   createSMESHAction(  2022, "SHOW_DISTRIBUTION","",0, true );
3538 #ifndef DISABLE_PLOT2DVIEWER
3539   createSMESHAction(  2023, "PLOT_DISTRIBUTION" );
3540 #endif
3541   createSMESHAction(  211, "WIRE",           "ICON_WIRE", 0, true );
3542   createSMESHAction(  212, "SHADE",          "ICON_SHADE", 0, true );
3543   createSMESHAction(  213, "SHRINK",         "ICON_SHRINK", 0, true );
3544   createSMESHAction(  214, "UPDATE",         "ICON_UPDATE" );
3545   createSMESHAction(  215, "NODES",          "ICON_POINTS", 0, true );
3546   createSMESHAction(  216, "ELEMS0D",        "ICON_DLG_ELEM0D", 0, true );
3547   createSMESHAction(  217, "EDGES",          "ICON_DLG_EDGE", 0, true );
3548   createSMESHAction(  218, "FACES",          "ICON_DLG_TRIANGLE", 0, true );
3549   createSMESHAction(  219, "VOLUMES",        "ICON_DLG_TETRAS", 0, true );
3550   createSMESHAction(  220, "ALL" );
3551   createSMESHAction(  221, "FACE_ORIENTATION", "", 0, true );
3552
3553   createSMESHAction(  231, "LINE_REPRESENTATION", "", 0, true );
3554   createSMESHAction(  232, "ARC_REPRESENTATION", "", 0, true );
3555
3556   createSMESHAction( 1100, "EDIT_HYPO" );
3557   createSMESHAction( 1102, "UNASSIGN" );
3558   createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3559   createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3560   createSMESHAction( 1131, "DISPMODE" );
3561   createSMESHAction( 1132, "COLORS" );
3562   createSMESHAction( 1133, "TRANSP" );
3563   createSMESHAction( 1134, "CLIP" );
3564   createSMESHAction( 1135, "DISP_ENT" );
3565   createSMESHAction( 1136, "AUTO_COLOR" );
3566   createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3567   createSMESHAction( 2000, "CTRL" );
3568
3569   createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3570   createSMESHAction( 502, "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
3571
3572   createSMESHAction( 300, "ERASE" );
3573   createSMESHAction( 301, "DISPLAY" );
3574   createSMESHAction( 302, "DISPLAY_ONLY" );
3575
3576   // ----- create menu --------------
3577   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
3578       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
3579       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
3580       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
3581       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
3582       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
3583       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3584       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
3585
3586   createMenu( separator(), fileId );
3587
3588   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3589       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3590       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3591       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3592       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3593       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3594       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
3595       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3596       renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
3597       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3598
3599   createMenu( 111, importId, -1 );
3600   createMenu( 112, importId, -1 );
3601   createMenu( 113, importId, -1 );
3602   createMenu( 115, importId, -1 );
3603 #ifdef WITH_CGNS
3604   createMenu( 116, importId, -1 );
3605 #endif
3606   createMenu( 117, importId, -1 );
3607   createMenu( 121, exportId, -1 );
3608   createMenu( 122, exportId, -1 );
3609   createMenu( 123, exportId, -1 );
3610   createMenu( 140, exportId, -1 ); // export to STL
3611 #ifdef WITH_CGNS
3612   createMenu( 142, exportId, -1 ); // export to CGNS
3613 #endif
3614   createMenu( 144, exportId, -1 ); // export to SAUV
3615   createMenu( separator(), fileId, 10 );
3616
3617   createMenu( 33, editId, -1 );
3618
3619   createMenu( 5105, toolsId, -1 );
3620
3621   createMenu( 702, meshId, -1 ); // "Mesh" menu
3622   createMenu( 703, meshId, -1 );
3623   createMenu( 704, meshId, -1 );
3624   createMenu( 710, meshId, -1 );
3625   createMenu( 705, meshId, -1 );
3626   createMenu( separator(), meshId, -1 );
3627   createMenu( 701, meshId, -1 );
3628   createMenu( 711, meshId, -1 );
3629   createMenu( 712, meshId, -1 );
3630   createMenu( 713, meshId, -1 );
3631   createMenu( separator(), meshId, -1 );
3632   createMenu( 801, meshId, -1 );
3633   createMenu( 806, meshId, -1 );
3634   createMenu( 802, meshId, -1 );
3635   createMenu( 803, meshId, -1 );
3636   createMenu( 815, meshId, -1 );
3637   createMenu( separator(), meshId, -1 );
3638   createMenu( 810, meshId, -1 );
3639   createMenu( 811, meshId, -1 );
3640   createMenu( 812, meshId, -1 );
3641   createMenu( separator(), meshId, -1 );
3642   createMenu( 814, meshId, -1 );
3643   createMenu( separator(), meshId, -1 );
3644   createMenu( 900, meshId, -1 );
3645   //createMenu( 902, meshId, -1 );
3646   //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3647   createMenu( 904, meshId, -1 );
3648   createMenu( separator(), meshId, -1 );
3649
3650   createMenu( 6005, nodeId, -1 );
3651   createMenu( 6028, nodeId, -1 );
3652   createMenu( 6002, edgeId, -1 );
3653   createMenu( 6003, edgeId, -1 );
3654   createMenu( 6001, edgeId, -1 );
3655   createMenu( 6004, edgeId, -1 );
3656   createMenu( 6029, edgeId, -1 );
3657   createMenu( 6021, faceId, -1 );
3658   createMenu( 6025, faceId, -1 );
3659   createMenu( 6027, faceId, -1 );
3660   createMenu( 6018, faceId, -1 );
3661   createMenu( 6019, faceId, -1 );
3662   createMenu( 6011, faceId, -1 );
3663   createMenu( 6012, faceId, -1 );
3664   createMenu( 6013, faceId, -1 );
3665   createMenu( 6014, faceId, -1 );
3666   createMenu( 6015, faceId, -1 );
3667   createMenu( 6016, faceId, -1 );
3668   createMenu( 6022, faceId, -1 );
3669   createMenu( 6030, faceId, -1 );
3670   createMenu( 6017, volumeId, -1 );
3671   createMenu( 6009, volumeId, -1 );
3672   createMenu( 6023, volumeId, -1 );
3673   createMenu( 6024, volumeId, -1 );
3674   createMenu( 6026, volumeId, -1 );
3675   createMenu( 6031, volumeId, -1 );
3676
3677   createMenu( 4000, addId, -1 );
3678   createMenu( 4009, addId, -1 );
3679   createMenu( 4010, addId, -1 );
3680   createMenu( 4021, addId, -1 );
3681   createMenu( 4022, addId, -1 );
3682   createMenu( 4023, addId, -1 );
3683   createMenu( 4031, addId, -1 );
3684   createMenu( 4032, addId, -1 );
3685   createMenu( 4133, addId, -1 );
3686   createMenu( 4134, addId, -1 );
3687   createMenu( 4135, addId, -1 );
3688   createMenu( 4033, addId, -1 );
3689   createMenu( separator(), addId, -1 );
3690   createMenu( 4034, addId, -1 );
3691   createMenu( 4035, addId, -1 );
3692   createMenu( 4036, addId, -1 );
3693   createMenu( 4136, addId, -1 );
3694   createMenu( 4037, addId, -1 );
3695   createMenu( 4038, addId, -1 );
3696   createMenu( 4039, addId, -1 );
3697   createMenu( 4040, addId, -1 );
3698   createMenu( 4140, addId, -1 );
3699
3700   createMenu( 4041, removeId, -1 );
3701   createMenu( 4042, removeId, -1 );
3702   createMenu( 4044, removeId, -1 );
3703   createMenu( separator(), removeId, -1 );
3704   createMenu( 813, removeId, -1 );
3705   createMenu( separator(), removeId, -1 );
3706   createMenu( 4043, removeId, -1 );
3707
3708   createMenu( 4051, renumId, -1 );
3709   createMenu( 4052, renumId, -1 );
3710
3711   createMenu( 4061, transfId, -1 );
3712   createMenu( 4062, transfId, -1 );
3713   createMenu( 4063, transfId, -1 );
3714   createMenu( 4068, transfId, -1 );
3715   createMenu( 4064, transfId, -1 );
3716   createMenu( 4065, transfId, -1 );
3717   createMenu( 4066, transfId, -1 );
3718   createMenu( 4069, transfId, -1 );
3719
3720   createMenu( 4067,modifyId, -1 );
3721   createMenu( 407, modifyId, -1 );
3722   createMenu( 408, modifyId, -1 );
3723   createMenu( 409, modifyId, -1 );
3724   createMenu( 410, modifyId, -1 );
3725   createMenu( 411, modifyId, -1 );
3726   createMenu( 419, modifyId, -1 );
3727   createMenu( 412, modifyId, -1 );
3728   createMenu( 413, modifyId, -1 );
3729   createMenu( 416, modifyId, -1 );
3730   createMenu( 414, modifyId, -1 );
3731   createMenu( 415, modifyId, -1 );
3732   createMenu( 417, modifyId, -1 );
3733   createMenu( 418, modifyId, -1 );
3734
3735   createMenu( 501, measureId, -1 );
3736   createMenu( 502, measureId, -1 );
3737   createMenu( 214, viewId, -1 );
3738
3739   // ----- create toolbars --------------
3740   int meshTb     = createTool( tr( "TB_MESH" ) ),
3741       ctrlTb     = createTool( tr( "TB_CTRL" ) ),
3742       addRemTb   = createTool( tr( "TB_ADD_REMOVE" ) ),
3743       modifyTb   = createTool( tr( "TB_MODIFY" ) ),
3744       dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3745
3746   createTool( 702, meshTb );
3747   createTool( 703, meshTb );
3748   createTool( 704, meshTb );
3749   createTool( 710, meshTb );
3750   createTool( 705, meshTb );
3751   createTool( separator(), meshTb );
3752   createTool( 701, meshTb );
3753   createTool( 711, meshTb );
3754   createTool( 712, meshTb );
3755   createTool( 713, meshTb );
3756   createTool( separator(), meshTb );
3757   createTool( 801, meshTb );
3758   createTool( 806, meshTb );
3759   createTool( 802, meshTb );
3760   createTool( 803, meshTb );
3761   //createTool( 815, meshTb );
3762   createTool( separator(), meshTb );
3763   createTool( 900, meshTb );
3764   //createTool( 902, meshTb );
3765   //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3766   createTool( 904, meshTb );
3767   createTool( separator(), meshTb );
3768
3769   createTool( 6005, ctrlTb );
3770   createTool( 6028, ctrlTb );
3771   createTool( separator(), ctrlTb );
3772   createTool( 6002, ctrlTb );
3773   createTool( 6003, ctrlTb );
3774   createTool( 6001, ctrlTb );
3775   createTool( 6004, ctrlTb );
3776   createTool( 6029, ctrlTb );
3777   createTool( separator(), ctrlTb );
3778   createTool( 6021, ctrlTb );
3779   createTool( 6025, ctrlTb );
3780   createTool( 6027, ctrlTb );
3781   createTool( 6018, ctrlTb );
3782   createTool( 6019, ctrlTb );
3783   createTool( 6011, ctrlTb );
3784   createTool( 6012, ctrlTb );
3785   createTool( 6013, ctrlTb );
3786   createTool( 6014, ctrlTb );
3787   createTool( 6015, ctrlTb );
3788   createTool( 6016, ctrlTb );
3789   createTool( 6022, ctrlTb );
3790   createTool( 6030, ctrlTb );
3791   createTool( separator(), ctrlTb );
3792   createTool( 6017, ctrlTb );
3793   createTool( 6009, ctrlTb );
3794   createTool( 6023, ctrlTb );
3795   createTool( 6024, ctrlTb );
3796   createTool( 6026, ctrlTb );
3797   createTool( 6031, ctrlTb );
3798   createTool( separator(), ctrlTb );
3799
3800   createTool( 4000, addRemTb );
3801   createTool( 4009, addRemTb );
3802   createTool( 4010, addRemTb );
3803   createTool( 4021, addRemTb );
3804   createTool( 4022, addRemTb );
3805   createTool( 4023, addRemTb );
3806   createTool( 4031, addRemTb );
3807   createTool( 4032, addRemTb );
3808   createTool( 4133, addRemTb );
3809   createTool( 4134, addRemTb );
3810   createTool( 4135, addRemTb );
3811   createTool( 4033, addRemTb );
3812   createTool( separator(), addRemTb );
3813   createTool( 4034, addRemTb );
3814   createTool( 4035, addRemTb );
3815   createTool( 4036, addRemTb );
3816   createTool( 4136, addRemTb );
3817   createTool( 4037, addRemTb );
3818   createTool( 4038, addRemTb );
3819   createTool( 4039, addRemTb );
3820   createTool( 4040, addRemTb );
3821   createTool( 4140, addRemTb );
3822   createTool( separator(), addRemTb );
3823   createTool( 4041, addRemTb );
3824   createTool( 4042, addRemTb );
3825   createTool( 4044, addRemTb );
3826   createTool( 4043, addRemTb );
3827   createTool( separator(), addRemTb );
3828   createTool( 4051, addRemTb );
3829   createTool( 4052, addRemTb );
3830   createTool( separator(), addRemTb );
3831   createTool( 4061, addRemTb );
3832   createTool( 4062, addRemTb );
3833   createTool( 4063, addRemTb );
3834   createTool( 4068, addRemTb );
3835   createTool( 4064, addRemTb );
3836   createTool( 4065, addRemTb );
3837   createTool( 4066, addRemTb );
3838   createTool( 4069, addRemTb );
3839   createTool( separator(), addRemTb );
3840
3841   createTool( 4067,modifyTb );
3842   createTool( 407, modifyTb );
3843   createTool( 408, modifyTb );
3844   createTool( 409, modifyTb );
3845   createTool( 410, modifyTb );
3846   createTool( 411, modifyTb );
3847   createTool( 419, modifyTb );
3848   createTool( 412, modifyTb );
3849   createTool( 413, modifyTb );
3850   createTool( 416, modifyTb );
3851   createTool( 414, modifyTb );
3852   createTool( 415, modifyTb );
3853   createTool( 417, modifyTb );
3854   createTool( 418, modifyTb );
3855
3856   createTool( 214, dispModeTb );
3857
3858   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3859   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3860
3861   myRules.clear();
3862   QString OB = "'ObjectBrowser'",
3863           View = "'" + SVTK_Viewer::Type() + "'",
3864           pat = "'%1'",
3865           mesh    = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
3866           group   = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
3867           hypo    = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
3868           algo    = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
3869           elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
3870                        arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
3871                        arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
3872                        arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
3873                        arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
3874                        arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
3875                        arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
3876           subMesh = elems,
3877           mesh_part = mesh + " " + subMesh + " " + group,
3878           mesh_group = mesh + " " + group,
3879           hyp_alg = hypo + " " + algo;
3880
3881   // popup for object browser
3882   QString
3883     isInvisible("not( isVisible )"),
3884     isEmpty("numberOfNodes = 0"),
3885     isNotEmpty("numberOfNodes <> 0"),
3886
3887     // has nodes, edges, etc in VISIBLE! actor
3888     hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
3889     hasElems("(count( elemTypes ) > 0)"),
3890     hasDifferentElems("(count( elemTypes ) > 1)"),
3891     hasElems0d("({'Elem0d'} in elemTypes)"),
3892     hasEdges("({'Edge'} in elemTypes)"),
3893     hasFaces("({'Face'} in elemTypes)"),
3894     hasVolumes("({'Volume'} in elemTypes)");
3895
3896   createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" );      // FILE INFORMATION
3897   createPopupItem( 703, OB, mesh, "&& isComputable");      // CREATE_SUBMESH
3898   createPopupItem( 704, OB, mesh, "&& isComputable");      // EDIT_MESHSUBMESH
3899   createPopupItem( 704, OB, subMesh, "&& isComputable" );  // EDIT_MESHSUBMESH
3900   createPopupItem( 803, OB, group );                       // EDIT_GROUP
3901   createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
3902
3903   popupMgr()->insert( separator(), -1, 0 );
3904   createPopupItem( 701, OB, mesh, "&& isComputable" );     // COMPUTE
3905   createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
3906   createPopupItem( 712, OB, mesh, "&& isComputable" );     // EVALUATE
3907   createPopupItem( 713, OB, mesh, "&& isComputable" );     // MESH ORDER
3908   createPopupItem( 214, OB, mesh_part );                   // UPDATE
3909   createPopupItem( 900, OB, mesh_part );                   // ADV_INFO
3910   createPopupItem( 904, OB, mesh_group );                  // FIND_ELEM
3911   popupMgr()->insert( separator(), -1, 0 );
3912   createPopupItem( 801, OB, mesh );                        // CREATE_GROUP
3913   createPopupItem( 806, OB, mesh );                        // CREATE_GEO_GROUP
3914   createPopupItem( 802, OB, subMesh );                     // CONSTRUCT_GROUP
3915   popupMgr()->insert( separator(), -1, 0 );
3916   createPopupItem( 1100, OB, hypo);                        // EDIT HYPOTHESIS
3917   createPopupItem( 1102, OB, hyp_alg );                    // REMOVE HYPOTHESIS / ALGORITHMS
3918   popupMgr()->insert( separator(), -1, 0 );
3919   createPopupItem( 4043, OB, mesh );                       // CLEAR_MESH
3920   popupMgr()->insert( separator(), -1, 0 );
3921   createPopupItem( 417, OB, mesh + " " + subMesh );        // convert to quadratic
3922   createPopupItem( 418, OB, mesh + " " + group,            // create 2D mesh from 3D
3923                    "&& dim>=2");
3924   popupMgr()->insert( separator(), -1, 0 );
3925
3926   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
3927   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
3928   QString only_one_2D        = only_one_non_empty + " && dim>1";
3929
3930   createPopupItem( 125, OB, mesh_group, multiple_non_empty );   // EXPORT_MED
3931   createPopupItem( 126, OB, mesh_group, only_one_non_empty );   // EXPORT_UNV
3932   createPopupItem( 141, OB, mesh_group, only_one_2D );          // EXPORT_STL
3933 #ifdef WITH_CGNS
3934   createPopupItem( 143, OB, mesh_group, multiple_non_empty );   // EXPORT_CGNS
3935 #endif
3936   createPopupItem( 145, OB, mesh_group, multiple_non_empty );   // EXPORT_SAUV
3937   createPopupItem(  33, OB, mesh_part + " " + hyp_alg );        // DELETE
3938   popupMgr()->insert( separator(), -1, 0 );
3939
3940   // popup for viewer
3941   createPopupItem( 803, View, group ); // EDIT_GROUP
3942   createPopupItem( 804, View, elems ); // ADD
3943   createPopupItem( 805, View, elems ); // REMOVE
3944
3945   popupMgr()->insert( separator(), -1, 0 );
3946   createPopupItem( 214, View, mesh_part );  // UPDATE
3947   createPopupItem( 900, View, mesh_part );  // ADV_INFO
3948   createPopupItem( 904, View, mesh );       // FIND_ELEM
3949   popupMgr()->insert( separator(), -1, 0 );
3950
3951   createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
3952   createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" );       // DISABLE_AUTO_COLOR
3953   popupMgr()->insert( separator(), -1, 0 );
3954
3955   int anId;
3956   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
3957   QString aType = QString( "%1type in {%2}" ).arg( lc );
3958   aType = aType.arg( mesh_part );
3959   QString aMeshInVTK = aClient + "&&" + aType;
3960
3961   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
3962   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
3963   QString aSelCount = QString( "%1 > 0" ).arg( dc );
3964
3965   //-------------------------------------------------
3966   // Numbering
3967   //-------------------------------------------------
3968   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
3969
3970   popupMgr()->insert( action( 9010 ), anId, -1 );
3971   popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
3972   popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
3973
3974   popupMgr()->insert( action( 9011 ), anId, -1 );
3975   popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
3976   popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
3977
3978   popupMgr()->insert( separator(), -1, -1 );
3979
3980   //-------------------------------------------------
3981   // Display Mode
3982   //-------------------------------------------------
3983   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
3984
3985   popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
3986   popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
3987   popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
3988
3989   popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
3990   popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
3991   popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
3992
3993   popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
3994   popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
3995   popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
3996
3997   popupMgr()->insert( separator(), anId, -1 );
3998
3999   popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4000   popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4001   popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4002
4003   //-------------------------------------------------
4004   // Display Entity
4005   //-------------------------------------------------
4006   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4007
4008   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4009
4010   popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4011   popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4012   popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4013
4014   popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4015   popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4016   popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4017
4018   popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4019   popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4020   popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4021
4022   popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4023   popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4024   popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4025
4026   popupMgr()->insert( separator(), anId, -1 );
4027
4028   popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4029   popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4030
4031
4032   //-------------------------------------------------
4033   // Representation of the 2D Quadratic elements
4034   //-------------------------------------------------
4035   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4036   popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4037   popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4038   popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4039
4040   popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4041   popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4042   popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4043
4044   //-------------------------------------------------
4045   // Orientation of faces
4046   //-------------------------------------------------
4047   popupMgr()->insert( action( 221 ), -1, -1 );
4048   popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4049   popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4050
4051   //-------------------------------------------------
4052   // Color / Size
4053   //-------------------------------------------------
4054   popupMgr()->insert( action( 1132 ), -1, -1 );
4055   popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4056
4057   //-------------------------------------------------
4058   // Transparency
4059   //-------------------------------------------------
4060   popupMgr()->insert( action( 1133 ), -1, -1 );
4061   popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4062
4063   //-------------------------------------------------
4064   // Controls
4065   //-------------------------------------------------
4066   QString
4067     aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4068     aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4069     aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4070     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4071
4072   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4073
4074   popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4075   popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4076
4077   popupMgr()->insert( separator(), anId, -1 );
4078
4079   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4080
4081   popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4082   popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4083   popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4084
4085   popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4086   popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4087   popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4088
4089   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4090
4091   popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4092   popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4093   popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4094
4095   popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4096   popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4097   popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4098
4099   popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4100   popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4101   popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4102
4103   popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4104   popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4105   popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4106   popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4107   popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4108   popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4109
4110   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4111
4112   popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4113   popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4114                                        QtxPopupMgr::VisibleRule );
4115   popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4116
4117   popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4118   popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4119   popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4120
4121   popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4122   popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4123   popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4124
4125   popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4126   popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4127   popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4128
4129   popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4130   popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4131   popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4132
4133   popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4134   popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4135   popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4136
4137   popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4138   popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4139   popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4140
4141   popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4142   popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4143   popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4144
4145   popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4146   popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4147   popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4148
4149   popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4150   popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4151   popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4152
4153   popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4154   popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4155   popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4156
4157   popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4158   popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4159   popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4160   popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4161   popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4162   popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4163
4164   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4165
4166   popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4167   popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4168   popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4169
4170   popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4171   popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4172   popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4173
4174   popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4175   popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4176   popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4177
4178   popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4179   popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4180   popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4181
4182   popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4183   popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4184   popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4185
4186   popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4187   popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4188   popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4189
4190   popupMgr()->insert( separator(), anId, -1 );
4191
4192   popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4193   popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4194
4195   popupMgr()->insert( separator(), anId, -1 );
4196
4197   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4198
4199   popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4200   popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4201
4202   popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4203   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4204   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4205
4206 #ifndef DISABLE_PLOT2DVIEWER
4207   popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4208   popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4209 #endif
4210
4211   //-------------------------------------------------
4212   // Display / Erase
4213   //-------------------------------------------------
4214   popupMgr()->insert( separator(), -1, -1 );
4215   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4216     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4217   popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4218   popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4219
4220   popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4221   popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4222
4223   popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4224   popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4225
4226   popupMgr()->insert( separator(), -1, -1 );
4227
4228   //-------------------------------------------------
4229   // Clipping
4230   //-------------------------------------------------
4231   popupMgr()->insert( action( 1134 ), -1, -1 );
4232   popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4233
4234   popupMgr()->insert( separator(), -1, -1 );
4235
4236   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4237            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4238
4239   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4240            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4241 }
4242
4243 //================================================================================
4244 /*!
4245  * \brief Return true if SMESH or GEOM objects are selected.
4246  * Is called form LightApp_Module::activateModule() which clear selection if
4247  * not isSelectionCompatible()
4248  */
4249 //================================================================================
4250
4251 bool SMESHGUI::isSelectionCompatible()
4252 {
4253   bool isCompatible = true;
4254   SALOME_ListIO selected;
4255   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4256     Sel->selectedObjects( selected );
4257
4258   SALOME_ListIteratorOfListIO It( selected );
4259   for ( ; isCompatible && It.More(); It.Next())
4260     isCompatible =
4261       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4262       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4263
4264   return isCompatible;
4265 }
4266
4267
4268 bool SMESHGUI::reusableOperation( const int id )
4269 {
4270   // compute, evaluate and precompute are not reusable operations
4271   return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4272 }
4273
4274 bool SMESHGUI::activateModule( SUIT_Study* study )
4275 {
4276   bool res = SalomeApp_Module::activateModule( study );
4277
4278   setMenuShown( true );
4279   setToolShown( true );
4280
4281   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4282   PyGILState_STATE gstate = PyGILState_Ensure();
4283   PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4284   if(pluginsmanager==NULL)
4285     PyErr_Print();
4286   else
4287     {
4288       PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4289       if(result==NULL)
4290         PyErr_Print();
4291       Py_XDECREF(result);
4292     }
4293   PyGILState_Release(gstate);
4294   // end of GEOM plugins loading
4295
4296   // Reset actions accelerator keys
4297   action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4298   action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4299   action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4300
4301   action(  33)->setEnabled(true); // Delete: Key_Delete
4302
4303   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4304   GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4305   if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4306     if ( _PTR(Study) aStudy = s->studyDS()) {
4307       GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4308       updateObjBrowser(); // objects can be removed
4309     }
4310
4311   // get all view currently opened in the study and connect their signals  to
4312   // the corresponding slots of the class.
4313   SUIT_Desktop* aDesk = study->application()->desktop();
4314   if ( aDesk ) {
4315     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4316     SUIT_ViewWindow* wnd;
4317     foreach ( wnd, wndList )
4318       connectView( wnd );
4319   }
4320
4321   return res;
4322 }
4323
4324 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4325 {
4326   setMenuShown( false );
4327   setToolShown( false );
4328
4329   EmitSignalCloseAllDialogs();
4330
4331   // Unset actions accelerator keys
4332   action(111)->setShortcut(QKeySequence()); // Import DAT
4333   action(112)->setShortcut(QKeySequence()); // Import UNV
4334   action(113)->setShortcut(QKeySequence()); // Import MED
4335
4336   action(  33)->setEnabled(false); // Delete: Key_Delete
4337
4338   return SalomeApp_Module::deactivateModule( study );
4339 }
4340
4341 void SMESHGUI::studyClosed( SUIT_Study* s )
4342 {
4343   SMESH::RemoveVisuData( s->id() );
4344   SalomeApp_Module::studyClosed( s );
4345 }
4346
4347 void SMESHGUI::OnGUIEvent()
4348 {
4349   const QObject* obj = sender();
4350   if ( !obj || !obj->inherits( "QAction" ) )
4351     return;
4352   int id = actionId((QAction*)obj);
4353   if ( id != -1 )
4354     OnGUIEvent( id );
4355 }
4356
4357 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4358 {
4359   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4360   if ( CORBA::is_nil( myComponentSMESH ) )
4361     {
4362       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4363       if ( aStudy )
4364         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4365       return aGUI.myComponentSMESH;
4366     }
4367   if ( aStudy )
4368     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4369   return myComponentSMESH;
4370 }
4371
4372 QString SMESHGUI::engineIOR() const
4373 {
4374   CORBA::ORB_var anORB = getApp()->orb();
4375   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4376   return QString( anIOR.in() );
4377 }
4378
4379 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4380 {
4381   SalomeApp_Module::contextMenuPopup( client, menu, title );
4382   SALOME_ListIO lst;
4383   selectionMgr()->selectedObjects( lst );
4384   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4385     Handle(SALOME_InteractiveObject) io = lst.First();
4386     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4387     _PTR(Study) study = appStudy->studyDS();
4388     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4389     if ( obj ) {
4390       QString aName = QString( obj->GetName().c_str() );
4391       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4392           aName.remove( (aName.length() - 1), 1 );
4393       title = aName;
4394     }
4395   }
4396 }
4397
4398 LightApp_Selection* SMESHGUI::createSelection() const
4399 {
4400   return new SMESHGUI_Selection();
4401 }
4402
4403 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4404 {
4405   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4406   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4407 }
4408
4409 void SMESHGUI::viewManagers( QStringList& list ) const
4410 {
4411   list.append( SVTK_Viewer::Type() );
4412 }
4413
4414 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4415 {
4416   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4417     SMESH::UpdateSelectionProp( this );
4418
4419     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4420     for(int i = 0; i < aViews.count() ; i++){
4421       SUIT_ViewWindow *sf = aViews[i];
4422       connectView( sf );
4423     }
4424   }
4425 }
4426
4427 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4428 {
4429   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4430     myClippingPlaneInfoMap.erase( theViewManager );
4431 }
4432
4433 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4434 {
4435   theActor->AddObserver( SMESH::DeleteActorEvent,
4436                          myEventCallbackCommand.GetPointer(),
4437                          myPriority );
4438 }
4439
4440 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4441                               unsigned long theEvent,
4442                               void* theClientData,
4443                               void* theCallData )
4444 {
4445   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4446     if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4447       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4448         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4449         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4450         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4451           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4452           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4453           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4454             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4455             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4456             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4457             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4458               if( anActor == *anIter3 ) {
4459                 anActorList.erase( anIter3 );
4460                 break;
4461               }
4462             }
4463           }
4464         }
4465       }
4466     }
4467   }
4468 }
4469
4470 void SMESHGUI::createPreferences()
4471 {
4472   // General tab ------------------------------------------------------------------------
4473   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4474
4475   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4476   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4477   setPreferenceProperty( lim, "min",  0 );
4478   setPreferenceProperty( lim, "max",  100000000 );
4479   setPreferenceProperty( lim, "step", 1000 );
4480   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4481
4482   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4483   setPreferenceProperty( qaGroup, "columns", 2 );
4484   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4485   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4486   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4487   setPreferenceProperty( prec, "min", 0 );
4488   setPreferenceProperty( prec, "max", 16 );
4489   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4490   setPreferenceProperty( doubleNodesTol, "precision", 10 );
4491   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4492   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4493   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4494
4495   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4496   setPreferenceProperty( dispgroup, "columns", 2 );
4497   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4498   QStringList modes;
4499   modes.append( tr("MEN_WIRE") );
4500   modes.append( tr("MEN_SHADE") );
4501   modes.append( tr("MEN_NODES") );
4502   modes.append( tr("MEN_SHRINK") );
4503   QList<QVariant> indices;
4504   indices.append( 0 );
4505   indices.append( 1 );
4506   indices.append( 2 );
4507   indices.append( 3 );
4508   setPreferenceProperty( dispmode, "strings", modes );
4509   setPreferenceProperty( dispmode, "indexes", indices );
4510
4511   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4512   setPreferenceProperty( arcgroup, "columns", 2 );
4513   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4514   QStringList quadraticModes;
4515   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4516   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4517   indices.clear();
4518   indices.append( 0 );
4519   indices.append( 1 );
4520   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4521   setPreferenceProperty( quadraticmode, "indexes", indices );
4522
4523   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4524                               "SMESH", "max_angle" );
4525   setPreferenceProperty( maxAngle, "min", 1 );
4526   setPreferenceProperty( maxAngle, "max", 90 );
4527
4528
4529
4530   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4531   setPreferenceProperty( exportgroup, "columns", 2 );
4532   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4533   addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4534
4535   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4536   setPreferenceProperty( computeGroup, "columns", 2 );
4537   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4538   modes.clear();
4539   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4540   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4541   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4542   indices.clear();
4543   indices.append( 0 );
4544   indices.append( 1 );
4545   indices.append( 2 );
4546   setPreferenceProperty( notifyMode, "strings", modes );
4547   setPreferenceProperty( notifyMode, "indexes", indices );
4548
4549   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4550   setPreferenceProperty( infoGroup, "columns", 4 );
4551   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4552   modes.clear();
4553   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4554   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4555   indices.clear();
4556   indices.append( 0 );
4557   indices.append( 1 );
4558   setPreferenceProperty( elemInfo, "strings", modes );
4559   setPreferenceProperty( elemInfo, "indexes", indices );
4560   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4561   setPreferenceProperty( nodesLim, "min", 0 );
4562   setPreferenceProperty( nodesLim, "max", 10000000 );
4563   setPreferenceProperty( nodesLim, "step", 10000 );
4564   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4565
4566   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4567   setPreferenceProperty( segGroup, "columns", 2 );
4568   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4569                               "SMESH", "segmentation" );
4570   setPreferenceProperty( segLen, "min", 1 );
4571   setPreferenceProperty( segLen, "max", 10000000 );
4572   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4573                              "SMESH", "nb_segments_per_edge" );
4574   setPreferenceProperty( nbSeg, "min", 1 );
4575   setPreferenceProperty( nbSeg, "max", 10000000 );
4576
4577   // Quantities with individual precision settings
4578   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4579   setPreferenceProperty( precGroup, "columns", 2 );
4580
4581   const int nbQuantities = 6;
4582   int precs[nbQuantities], ii = 0;
4583   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4584                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4585   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4586                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4587   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4588                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4589   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4590                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4591   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4592                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4593   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4594                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4595
4596   // Set property for precision value for spinboxes
4597   for ( ii = 0; ii < nbQuantities; ii++ ){
4598     setPreferenceProperty( precs[ii], "min", -14 );
4599     setPreferenceProperty( precs[ii], "max", 14 );
4600     setPreferenceProperty( precs[ii], "precision", 2 );
4601   }
4602
4603   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4604   setPreferenceProperty( previewGroup, "columns", 2 );
4605   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4606   setPreferenceProperty( chunkSize, "min",  0 );
4607   setPreferenceProperty( chunkSize, "max",  1000 );
4608   setPreferenceProperty( chunkSize, "step", 50 );
4609
4610   // Mesh tab ------------------------------------------------------------------------
4611   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4612   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4613   setPreferenceProperty( nodeGroup, "columns", 3 );
4614
4615   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4616
4617   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4618
4619   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4620   QList<QVariant> aMarkerTypeIndicesList;
4621   QList<QVariant> aMarkerTypeIconsList;
4622   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4623     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4624     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4625     aMarkerTypeIndicesList << i;
4626     aMarkerTypeIconsList << pixmap;
4627   }
4628   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4629   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
4630
4631   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4632
4633   QList<QVariant> aMarkerScaleIndicesList;
4634   QStringList     aMarkerScaleValuesList;
4635   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4636     aMarkerScaleIndicesList << i;
4637     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4638   }
4639   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4640   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4641
4642   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4643   setPreferenceProperty( elemGroup, "columns", 2 );
4644
4645   int ColorId = addPreference( tr( "PREF_FILL"     ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4646   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4647
4648   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4649   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4650
4651   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4652
4653   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4654   setPreferenceProperty( grpGroup, "columns", 2 );
4655
4656   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4657
4658   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4659                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4660   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
4661                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
4662   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4663                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4664
4665   setPreferenceProperty( size0d, "min", 1 );
4666   setPreferenceProperty( size0d, "max", 10 );
4667
4668   setPreferenceProperty( elemW, "min", 1 );
4669   setPreferenceProperty( elemW, "max", 5 );
4670
4671   setPreferenceProperty( shrink, "min", 0 );
4672   setPreferenceProperty( shrink, "max", 100 );
4673
4674   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4675   setPreferenceProperty( orientGroup, "columns", 1 );
4676
4677   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4678   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4679
4680   setPreferenceProperty( orientScale, "min", 0.05 );
4681   setPreferenceProperty( orientScale, "max", 0.5 );
4682   setPreferenceProperty( orientScale, "step", 0.05 );
4683
4684   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4685
4686   // Selection tab ------------------------------------------------------------------------
4687   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4688
4689   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4690   setPreferenceProperty( selGroup, "columns", 2 );
4691
4692   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4693   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4694   int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" );
4695
4696   setPreferenceProperty( selW, "min", 1 );
4697   setPreferenceProperty( selW, "max", 5 );
4698
4699   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4700   setPreferenceProperty( preGroup, "columns", 2 );
4701
4702   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4703   int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" );
4704
4705   setPreferenceProperty( preW, "min", 1 );
4706   setPreferenceProperty( preW, "max", 5 );
4707
4708   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4709   setPreferenceProperty( precSelGroup, "columns", 2 );
4710
4711   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4712   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4713   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4714
4715   // Scalar Bar tab ------------------------------------------------------------------------
4716   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4717   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4718   setPreferenceProperty( fontGr, "columns", 2 );
4719
4720   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4721   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4722
4723   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4724   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4725
4726   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4727   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4728
4729   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4730   setPreferenceProperty( numcol, "min", 2 );
4731   setPreferenceProperty( numcol, "max", 256 );
4732
4733   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4734   setPreferenceProperty( numlab, "min", 2 );
4735   setPreferenceProperty( numlab, "max", 65 );
4736
4737   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4738   setPreferenceProperty( orientGr, "columns", 2 );
4739   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4740   QStringList orients;
4741   orients.append( tr( "SMESH_VERTICAL" ) );
4742   orients.append( tr( "SMESH_HORIZONTAL" ) );
4743   indices.clear(); indices.append( 0 ); indices.append( 1 );
4744   setPreferenceProperty( orient, "strings", orients );
4745   setPreferenceProperty( orient, "indexes", indices );
4746
4747   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4748   setPreferenceProperty( posVSizeGr, "columns", 2 );
4749   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4750   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4751   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4752   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4753   setPreferenceProperty( xv, "step", 0.1 );
4754   setPreferenceProperty( xv, "min", 0.0 );
4755   setPreferenceProperty( xv, "max", 1.0 );
4756   setPreferenceProperty( yv, "step", 0.1 );
4757   setPreferenceProperty( yv, "min", 0.0 );
4758   setPreferenceProperty( yv, "max", 1.0 );
4759   setPreferenceProperty( wv, "step", 0.1 );
4760   setPreferenceProperty( wv, "min", 0.0 );
4761   setPreferenceProperty( wv, "max", 1.0 );
4762   setPreferenceProperty( hv, "min", 0.0 );
4763   setPreferenceProperty( hv, "max", 1.0 );
4764   setPreferenceProperty( hv, "step", 0.1 );
4765
4766   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4767   setPreferenceProperty( posHSizeGr, "columns", 2 );
4768   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4769   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4770   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4771   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4772   setPreferenceProperty( xv, "min", 0.0 );
4773   setPreferenceProperty( xv, "max", 1.0 );
4774   setPreferenceProperty( xv, "step", 0.1 );
4775   setPreferenceProperty( xh, "min", 0.0 );
4776   setPreferenceProperty( xh, "max", 1.0 );
4777   setPreferenceProperty( xh, "step", 0.1 );
4778   setPreferenceProperty( yh, "min", 0.0 );
4779   setPreferenceProperty( yh, "max", 1.0 );
4780   setPreferenceProperty( yh, "step", 0.1 );
4781   setPreferenceProperty( wh, "min", 0.0 );
4782   setPreferenceProperty( wh, "max", 1.0 );
4783   setPreferenceProperty( wh, "step", 0.1 );
4784   setPreferenceProperty( hh, "min", 0.0 );
4785   setPreferenceProperty( hh, "max", 1.0 );
4786   setPreferenceProperty( hh, "step", 0.1 );
4787
4788   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4789   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4790   setPreferenceProperty( distributionGr, "columns", 3 );
4791   QStringList types;
4792   types.append( tr( "SMESH_MONOCOLOR" ) );
4793   types.append( tr( "SMESH_MULTICOLOR" ) );
4794   indices.clear(); indices.append( 0 ); indices.append( 1 );
4795   setPreferenceProperty( coloringType, "strings", types );
4796   setPreferenceProperty( coloringType, "indexes", indices );
4797   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4798
4799 }
4800
4801 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4802 {
4803   if( sect=="SMESH" ) {
4804     float sbX1,sbY1,sbW,sbH;
4805     float aTol = 1.00000009999999;
4806     std::string aWarning;
4807     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4808     if( name=="selection_object_color" || name=="selection_element_color" ||
4809         name=="selection_width" || name=="highlight_color" || name=="highlight_width" ||
4810         name=="selection_precision_node" || name=="selection_precision_element" ||
4811         name=="selection_precision_object")
4812       SMESH::UpdateSelectionProp( this );
4813     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4814       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4815       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4816       if(sbX1+sbW > aTol){
4817         aWarning = "Origin and Size Vertical: X+Width > 1\n";
4818         sbX1=0.01;
4819         sbW=0.08;
4820         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4821         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4822       }
4823     }
4824     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4825       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4826       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4827       if(sbY1+sbH > aTol){
4828         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4829         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4830         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4831       }
4832     }
4833     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
4834       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4835       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4836       if(sbX1+sbW > aTol){
4837         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4838         sbX1=0.1;
4839         sbW=0.08;
4840         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4841         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4842       }
4843     }
4844     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
4845       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4846       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4847       if(sbY1+sbH > aTol){
4848         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4849         sbY1=0.01;
4850         sbH=0.08;
4851         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4852         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4853       }
4854     }
4855     else if ( name == "segmentation" ) {
4856       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4857       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4858     }
4859     else if ( name == "nb_segments_per_edge" ) {
4860       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4861       myComponentSMESH->SetDefaultNbSegments( nbSeg );
4862     }
4863
4864     if(aWarning.size() != 0){
4865       aWarning += "The default values are applied instead.";
4866       SUIT_MessageBox::warning(SMESHGUI::desktop(),
4867                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4868                                QObject::tr(aWarning.c_str()));
4869     }
4870   }
4871 }
4872
4873 //================================================================================
4874 /*!
4875  * \brief Update something in accordance with update flags
4876   * \param theFlags - update flags
4877 *
4878 * Update viewer or/and object browser etc. in accordance with update flags ( see
4879 * LightApp_UpdateFlags enumeration ).
4880 */
4881 //================================================================================
4882 void SMESHGUI::update( const int flags )
4883 {
4884   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4885     SMESH::UpdateView();
4886   else
4887     SalomeApp_Module::update( flags );
4888 }
4889
4890 //================================================================================
4891 /*!
4892  * \brief Set default selection mode
4893 *
4894 * SLOT called when operation commited. Sets default selection mode
4895 */
4896 //================================================================================
4897 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4898 {
4899   SVTK_ViewWindow* vtkWnd =
4900     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4901   if ( vtkWnd )
4902     vtkWnd->SetSelectionMode( ActorSelection );
4903 }
4904
4905 //================================================================================
4906 /*!
4907  * \brief Set default selection mode
4908 *
4909 * SLOT called when operation aborted. Sets default selection mode
4910 */
4911 //================================================================================
4912 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4913 {
4914   SVTK_ViewWindow* vtkWnd =
4915     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4916   if ( vtkWnd )
4917     vtkWnd->SetSelectionMode( ActorSelection );
4918 }
4919
4920 //================================================================================
4921 /*!
4922  * \brief Creates operation with given identifier
4923   * \param id - identifier of operation to be started
4924   * \return Pointer on created operation or NULL if operation is not created
4925 *
4926 * Virtual method redefined from the base class creates operation with given id.
4927 * It is called called automatically from startOperation method of base class.
4928 */
4929 //================================================================================
4930 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4931 {
4932   LightApp_Operation* op = 0;
4933   // to do : create operation here
4934   switch( id )
4935   {
4936     case 417: //convert to quadratic
4937       op = new SMESHGUI_ConvToQuadOp();
4938     break;
4939     case 418: // create 2D mesh as boundary on 3D
4940       op = new SMESHGUI_Make2DFrom3DOp();
4941     break;
4942     case 701: // Compute mesh
4943       op = new SMESHGUI_ComputeOp();
4944     break;
4945     case 702: // Create mesh
4946       op = new SMESHGUI_MeshOp( true, true );
4947     break;
4948     case 703: // Create sub-mesh
4949       op = new SMESHGUI_MeshOp( true, false );
4950     break;
4951     case 704: // Edit mesh/sub-mesh
4952       op = new SMESHGUI_MeshOp( false );
4953     break;
4954     case 711: // Precompute mesh
4955       op = new SMESHGUI_PrecomputeOp();
4956     break;
4957     case 712: // Evaluate mesh
4958       op = new SMESHGUI_EvaluateOp();
4959     break;
4960     case 713: // Evaluate mesh
4961       op = new SMESHGUI_MeshOrderOp();
4962     break;
4963     case 806: // Create group on geom
4964       op = new SMESHGUI_GroupOnShapeOp();
4965       break;
4966     case 904: // Find element
4967       op = new SMESHGUI_FindElemByPointOp();
4968       break;
4969     case 4067: // make mesh pass through point
4970       op = new SMESHGUI_MakeNodeAtPointOp();
4971       break;
4972     default:
4973     break;
4974   }
4975
4976   if( !op )
4977     op = SalomeApp_Module::createOperation( id );
4978   return op;
4979 }
4980
4981 //================================================================================
4982 /*!
4983  * \brief Stops current operations and starts a given one
4984   * \param id - The id of the operation to start
4985  */
4986 //================================================================================
4987
4988 void SMESHGUI::switchToOperation(int id)
4989 {
4990   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
4991     activeStudy()->abortAllOperations();
4992   startOperation( id );
4993 }
4994
4995 LightApp_Displayer* SMESHGUI::displayer()
4996 {
4997   if( !myDisplayer )
4998     myDisplayer = new SMESHGUI_Displayer( getApp() );
4999   return myDisplayer;
5000 }
5001
5002 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5003 {
5004   int aHue = -1;
5005   int aTolerance = 64;
5006   int anIterations = 0;
5007   int aPeriod = 5;
5008
5009   while( 1 )
5010   {
5011     anIterations++;
5012     if( anIterations % aPeriod == 0 )
5013     {
5014       aTolerance /= 2;
5015       if( aTolerance < 1 )
5016         break;
5017     }
5018
5019     aHue = (int)( 360.0 * rand() / RAND_MAX );
5020
5021     bool ok = true;
5022     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5023     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5024     for( ; it != itEnd; ++it )
5025     {
5026       SALOMEDS::Color anAutoColor = *it;
5027       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5028
5029       int h, s, v;
5030       aQColor.getHsv( &h, &s, &v );
5031       if( abs( h - aHue ) < aTolerance )
5032       {
5033         ok = false;
5034         break;
5035       }
5036     }
5037
5038     if( ok )
5039       break;
5040   }
5041
5042   QColor aColor;
5043   aColor.setHsv( aHue, 255, 255 );
5044
5045   SALOMEDS::Color aSColor;
5046   aSColor.R = (double)aColor.red() / 255.0;
5047   aSColor.G = (double)aColor.green() / 255.0;
5048   aSColor.B = (double)aColor.blue() / 255.0;
5049
5050   return aSColor;
5051 }
5052
5053 const char gSeparator = '_'; // character used to separate parameter names
5054 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
5055 const char gPathSep   = '|'; // character used to separate paths
5056
5057 /*!
5058  * \brief Store visual parameters
5059  *
5060  * This method is called just before the study document is saved.
5061  * Store visual parameters in AttributeParameter attribue(s)
5062  */
5063 void SMESHGUI::storeVisualParameters (int savePoint)
5064 {
5065   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5066   if (!appStudy || !appStudy->studyDS())
5067     return;
5068   _PTR(Study) studyDS = appStudy->studyDS();
5069
5070   // componentName is used for encoding of entries when storing them in IParameters
5071   std::string componentName = myComponentSMESH->ComponentDataType();
5072   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5073   //if (!aSComponent) return;
5074
5075   // IParameters
5076   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5077                                                              componentName.c_str(),
5078                                                              savePoint);
5079   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5080
5081   // store map of custom markers
5082   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5083   if( !aMarkerMap.empty() )
5084   {
5085     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5086     for( ; anIter != aMarkerMap.end(); anIter++ )
5087     {
5088       int anId = anIter->first;
5089       VTK::MarkerData aMarkerData = anIter->second;
5090       std::string aMarkerFileName = aMarkerData.first;
5091       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5092       if( aMarkerTexture.size() < 3 )
5093         continue; // should contain at least width, height and the first value
5094
5095       QString aPropertyName( "texture" );
5096       aPropertyName += gSeparator;
5097       aPropertyName += QString::number( anId );
5098
5099       QString aPropertyValue = aMarkerFileName.c_str();
5100       aPropertyValue += gPathSep;
5101
5102       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5103       ushort aWidth = *aTextureIter++;
5104       ushort aHeight = *aTextureIter++;
5105       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5106       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5107       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5108         aPropertyValue += QString::number( *aTextureIter );
5109
5110       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5111     }
5112   }
5113
5114   // viewers counters are used for storing view_numbers in IParameters
5115   int vtkViewers = 0;
5116
5117   // main cycle to store parameters of displayed objects
5118   QList<SUIT_ViewManager*> lst;
5119   QList<SUIT_ViewManager*>::Iterator it;
5120   getApp()->viewManagers(lst);
5121   for (it = lst.begin(); it != lst.end(); it++)
5122   {
5123     SUIT_ViewManager* vman = *it;
5124     QString vType = vman->getType();
5125
5126     // saving VTK actors properties
5127     if (vType == SVTK_Viewer::Type())
5128     {
5129       // store the clipping planes attached to the view manager
5130       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5131       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5132       if( anIter != myClippingPlaneInfoMap.end() )
5133         aClippingPlaneInfoList = anIter->second;
5134
5135       if( !aClippingPlaneInfoList.empty() ) {
5136         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5137         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5138         {
5139           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5140           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5141
5142           QString aPropertyName( "ClippingPlane" );
5143           aPropertyName += gSeparator;
5144           aPropertyName += QString::number( vtkViewers );
5145           aPropertyName += gSeparator;
5146           aPropertyName += QString::number( anId );
5147
5148           QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5149           aPropertyValue += gDigitsSep;
5150           aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5151           aPropertyValue += gDigitsSep;
5152           aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5153           aPropertyValue += gDigitsSep;
5154           aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5155
5156           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5157         }
5158       }
5159
5160       QVector<SUIT_ViewWindow*> views = vman->getViews();
5161       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5162       {
5163         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5164         {
5165           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5166           vtkActorCollection* allActors = aCopy.GetActors();
5167           allActors->InitTraversal();
5168           while (vtkActor* actor = allActors->GetNextActor())
5169           {
5170             if (actor->GetVisibility()) // store only visible actors
5171             {
5172               SMESH_Actor* aSmeshActor = 0;
5173               if (actor->IsA("SMESH_Actor"))
5174                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5175               if (aSmeshActor && aSmeshActor->hasIO())
5176               {
5177                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5178                 if (io->hasEntry())
5179                 {
5180                   // entry is "encoded" = it does NOT contain component adress,
5181                   // since it is a subject to change on next component loading
5182                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5183
5184                   std::string param, vtkParam = vType.toLatin1().data();
5185                   vtkParam += gSeparator;
5186                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5187                   vtkParam += gSeparator;
5188
5189                   // Visibility
5190                   param = vtkParam + "Visibility";
5191                   ip->setParameter(entry, param, "On");
5192
5193                   // Representation
5194                   param = vtkParam + "Representation";
5195                   ip->setParameter(entry, param, QString::number
5196                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5197
5198                   // IsShrunk
5199                   param = vtkParam + "IsShrunk";
5200                   ip->setParameter(entry, param, QString::number
5201                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5202
5203                   // Displayed entities
5204                   unsigned int aMode = aSmeshActor->GetEntityMode();
5205                   bool isE = aMode & SMESH_Actor::eEdges;
5206                   bool isF = aMode & SMESH_Actor::eFaces;
5207                   bool isV = aMode & SMESH_Actor::eVolumes;
5208
5209                   QString modeStr ("e");
5210                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5211                   modeStr += gDigitsSep; modeStr += "f";
5212                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5213                   modeStr += gDigitsSep; modeStr += "v";
5214                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5215
5216                   param = vtkParam + "Entities";
5217                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5218
5219                   // Colors (surface:edge:)
5220                   vtkFloatingPointType r, g, b;
5221                   int delta;
5222
5223                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5224                   QString colorStr ("surface");
5225                   colorStr += gDigitsSep; colorStr += QString::number(r);
5226                   colorStr += gDigitsSep; colorStr += QString::number(g);
5227                   colorStr += gDigitsSep; colorStr += QString::number(b);
5228
5229                   colorStr += gDigitsSep; colorStr += "backsurface";
5230                   colorStr += gDigitsSep; colorStr += QString::number(delta);
5231
5232
5233                   aSmeshActor->GetEdgeColor(r, g, b);
5234                   colorStr += gDigitsSep; colorStr += "edge";
5235                   colorStr += gDigitsSep; colorStr += QString::number(r);
5236                   colorStr += gDigitsSep; colorStr += QString::number(g);
5237                   colorStr += gDigitsSep; colorStr += QString::number(b);
5238
5239                   aSmeshActor->GetNodeColor(r, g, b);
5240                   colorStr += gDigitsSep; colorStr += "node";
5241                   colorStr += gDigitsSep; colorStr += QString::number(r);
5242                   colorStr += gDigitsSep; colorStr += QString::number(g);
5243                   colorStr += gDigitsSep; colorStr += QString::number(b);
5244
5245                   aSmeshActor->GetOutlineColor(r, g, b);
5246                   colorStr += gDigitsSep; colorStr += "outline";
5247                   colorStr += gDigitsSep; colorStr += QString::number(r);
5248                   colorStr += gDigitsSep; colorStr += QString::number(g);
5249                   colorStr += gDigitsSep; colorStr += QString::number(b);
5250
5251                   param = vtkParam + "Colors";
5252                   ip->setParameter(entry, param, colorStr.toLatin1().data());
5253
5254                   // Sizes of lines and points
5255                   QString sizeStr ("line");
5256                   sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5257                   sizeStr += gDigitsSep; sizeStr += "shrink";
5258                   sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5259
5260                   param = vtkParam + "Sizes";
5261                   ip->setParameter(entry, param, sizeStr.toLatin1().data());
5262
5263                   // Point marker
5264                   QString markerStr;
5265
5266                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5267                   if( aMarkerType == VTK::MT_USER ) {
5268                     markerStr += "custom";
5269                     markerStr += gDigitsSep;
5270                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5271                   }
5272                   else {
5273                     markerStr += "std";
5274                     markerStr += gDigitsSep;
5275                     markerStr += QString::number( (int)aMarkerType );
5276                     markerStr += gDigitsSep;
5277                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5278                   }
5279
5280                   param = vtkParam + "PointMarker";
5281                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5282
5283                   // Opacity
5284                   param = vtkParam + "Opacity";
5285                   ip->setParameter(entry, param,
5286                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5287
5288                   // Clipping
5289                   param = vtkParam + "ClippingPlane";
5290                   int aPlaneId = 0;
5291                   if( !aClippingPlaneInfoList.empty() ) {
5292                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5293                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5294                     {
5295                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5296                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5297                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5298                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5299                         if( aSmeshActor == *anIter2 ) {
5300                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5301                                             QString::number( anId ).toLatin1().constData() );
5302                           break;
5303                         }
5304                       }
5305                     }
5306                   }
5307                   if( aPlaneId == 0 )
5308                     ip->setParameter( entry, param, "Off" );
5309                 } // if (io->hasEntry())
5310               } // SMESH_Actor && hasIO
5311             } // isVisible
5312           } // while.. actors traversal
5313         } // if (vtkView)
5314       } // for (views)
5315       vtkViewers++;
5316     } // if (SVTK view model)
5317   } // for (viewManagers)
5318 }
5319
5320 // data structures for clipping planes processing
5321 typedef struct {
5322   int Id;
5323   vtkIdType Orientation;
5324   vtkFloatingPointType Distance;
5325   vtkFloatingPointType Angle[2];
5326 } TPlaneData;
5327 typedef std::list<TPlaneData>         TPlaneDataList;
5328 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5329
5330 typedef std::list<vtkActor*>          TActorList;
5331 typedef struct {
5332   int PlaneId;
5333   TActorList ActorList;
5334   SUIT_ViewManager* ViewManager;
5335 } TPlaneInfo;
5336 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5337 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5338
5339 /*!
5340  * \brief Restore visual parameters
5341  *
5342  * This method is called after the study document is opened.
5343  * Restore visual parameters from AttributeParameter attribue(s)
5344  */
5345 void SMESHGUI::restoreVisualParameters (int savePoint)
5346 {
5347   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5348   if (!appStudy || !appStudy->studyDS())
5349     return;
5350   _PTR(Study) studyDS = appStudy->studyDS();
5351
5352   // componentName is used for encoding of entries when storing them in IParameters
5353   std::string componentName = myComponentSMESH->ComponentDataType();
5354   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5355   //if (!aSComponent) return;
5356
5357   // IParameters
5358   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5359                                                              componentName.c_str(),
5360                                                              savePoint);
5361   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5362
5363   // restore map of custom markers and map of clipping planes
5364   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5365   TPlaneDataMap aPlaneDataMap;
5366
5367   std::vector<std::string> properties = ip->getProperties();
5368   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5369   {
5370     std::string property = *propIt;
5371     QString aPropertyName( property.c_str() );
5372     QString aPropertyValue( ip->getProperty( property ).c_str() );
5373
5374     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5375     if( aPropertyNameList.isEmpty() )
5376       continue;
5377
5378     QString aPropertyType = aPropertyNameList[0];
5379     if( aPropertyType == "texture" )
5380     {
5381       if( aPropertyNameList.size() != 2 )
5382         continue;
5383
5384       bool ok = false;
5385       int anId = aPropertyNameList[1].toInt( &ok );
5386       if( !ok || anId < 1 )
5387         continue;
5388
5389       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5390       if( aPropertyValueList.size() != 2 )
5391         continue;
5392
5393       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5394       QString aMarkerTextureString = aPropertyValueList[1];
5395       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5396       if( aMarkerTextureStringList.size() != 3 )
5397         continue;
5398
5399       ok = false;
5400       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5401       if( !ok )
5402         continue;
5403
5404       ok = false;
5405       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5406       if( !ok )
5407         continue;
5408
5409       VTK::MarkerTexture aMarkerTexture;
5410       aMarkerTexture.push_back( aWidth );
5411       aMarkerTexture.push_back( aHeight );
5412
5413       QString aMarkerTextureData = aMarkerTextureStringList[2];
5414       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5415       {
5416         QChar aChar = aMarkerTextureData.at( i );
5417         if( aChar.isDigit() )
5418           aMarkerTexture.push_back( aChar.digitValue() );
5419       }
5420
5421       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5422     }
5423     else if( aPropertyType == "ClippingPlane" )
5424     {
5425       if( aPropertyNameList.size() != 3 )
5426         continue;
5427
5428       bool ok = false;
5429       int aViewId = aPropertyNameList[1].toInt( &ok );
5430       if( !ok || aViewId < 0 )
5431         continue;
5432
5433       ok = false;
5434       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5435       if( !ok || aClippingPlaneId < 0 )
5436         continue;
5437
5438       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5439       if( aPropertyValueList.size() != 4 )
5440         continue;
5441
5442       TPlaneData aPlaneData;
5443       aPlaneData.Id = aClippingPlaneId;
5444
5445       ok = false;
5446       aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5447       if( !ok )
5448         continue;
5449
5450       ok = false;
5451       aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5452       if( !ok )
5453         continue;
5454
5455       ok = false;
5456       aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5457       if( !ok )
5458         continue;
5459
5460       ok = false;
5461       aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5462       if( !ok )
5463         continue;
5464
5465       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5466       aPlaneDataList.push_back( aPlaneData );
5467     }
5468   }
5469
5470   TPlaneInfoMap aPlaneInfoMap;
5471
5472   std::vector<std::string> entries = ip->getEntries();
5473
5474   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5475   {
5476     // entry is a normal entry - it should be "decoded" (setting base adress of component)
5477     QString entry (ip->decodeEntry(*entIt).c_str());
5478
5479     // Check that the entry corresponds to a real object in the Study
5480     // as the object may be deleted or modified after the visual state is saved.
5481     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5482     if (!so) continue; //Skip the not existent entry
5483
5484     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5485     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5486
5487     std::vector<std::string>::iterator namesIt = paramNames.begin();
5488     std::vector<std::string>::iterator valuesIt = paramValues.begin();
5489
5490     // actors are stored in a map after displaying of them for
5491     // quicker access in the future: map < viewID to actor >
5492     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5493
5494     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5495     {
5496       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5497       // '_' is used as separator and should not be used in viewer type or parameter names.
5498       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5499       if (lst.size() != 3)
5500         continue;
5501
5502       QString viewerTypStr = lst[0];
5503       QString viewIndexStr = lst[1];
5504       QString paramNameStr = lst[2];
5505
5506       bool ok;
5507       int viewIndex = viewIndexStr.toUInt(&ok);
5508       if (!ok) // bad conversion of view index to integer
5509         continue;
5510
5511       // viewers
5512       if (viewerTypStr == SVTK_Viewer::Type())
5513       {
5514         SMESH_Actor* aSmeshActor = 0;
5515         if (vtkActors.IsBound(viewIndex))
5516           aSmeshActor = vtkActors.Find(viewIndex);
5517
5518         QList<SUIT_ViewManager*> lst;
5519         getApp()->viewManagers(viewerTypStr, lst);
5520
5521         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5522         SUIT_ViewManager* vman = NULL;
5523         if (viewIndex >= 0 && viewIndex < lst.count())
5524           vman = lst.at(viewIndex);
5525
5526         if (paramNameStr == "Visibility")
5527         {
5528           if (!aSmeshActor && displayer() && vman)
5529           {
5530             SUIT_ViewModel* vmodel = vman->getViewModel();
5531             // SVTK view model can be casted to SALOME_View
5532             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5533
5534             // store displayed actor in a temporary map for quicker
5535             // access later when restoring other parameters
5536             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5537             vtkRenderer* Renderer = vtkView->getRenderer();
5538             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5539             vtkActorCollection* theActors = aCopy.GetActors();
5540             theActors->InitTraversal();
5541             bool isFound = false;
5542             vtkActor *ac = theActors->GetNextActor();
5543             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5544               if (ac->IsA("SMESH_Actor")) {
5545                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5546                 if (aGeomAc->hasIO()) {
5547                   Handle(SALOME_InteractiveObject) io =
5548                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5549                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5550                     isFound = true;
5551                     vtkActors.Bind(viewIndex, aGeomAc);
5552                   }
5553                 }
5554               }
5555             }
5556           }
5557         } // if (paramNameStr == "Visibility")
5558         else
5559         {
5560           // the rest properties "work" with SMESH_Actor
5561           if (aSmeshActor)
5562           {
5563             QString val ((*valuesIt).c_str());
5564
5565             // Representation
5566             if (paramNameStr == "Representation") {
5567               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5568             }
5569             // IsShrunk
5570             else if (paramNameStr == "IsShrunk") {
5571               if (val.toInt()) {
5572                 if (!aSmeshActor->IsShrunk())
5573                   aSmeshActor->SetShrink();
5574               }
5575               else {
5576                 if (aSmeshActor->IsShrunk())
5577                   aSmeshActor->UnShrink();
5578               }
5579             }
5580             // Displayed entities
5581             else if (paramNameStr == "Entities") {
5582               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5583               if (mode.count() == 6) {
5584                 if (mode[0] != "e" || mode[2]  != "f" || mode[4] != "v") {
5585                   MESSAGE("Invalid order of data in Entities, must be: "
5586                           "e:0/1:f:0/1:v:0/1");
5587                 }
5588                 else {
5589                   unsigned int aMode = aSmeshActor->GetEntityMode();
5590                   unsigned int aNewMode =
5591                     (int(SMESH_Actor::eEdges  ) * mode[1].toInt()) |
5592                     (int(SMESH_Actor::eFaces  ) * mode[3].toInt()) |
5593                     (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5594                   if (aNewMode != aMode)
5595                     aSmeshActor->SetEntityMode(aNewMode);
5596                 }
5597               }
5598             }
5599             // Colors
5600             else if (paramNameStr == "Colors") {
5601               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5602               if (colors.count() == 16 || colors.count() == 18 ) {
5603                 if (colors[0] != "surface" || colors[4]  != "backsurface" ||
5604                     (colors[8] != "edge" && colors[6] != "edge" ) || (colors[12] != "node" && colors[10] != "node") ||
5605                     (colors.count() == 18 && colors[14] != "outline")) {
5606                   MESSAGE("Invalid order of data in Colors, must be: "
5607                           "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b or surface:r:g:b:backsurface:delta:edge:r:g:b:node:r:g:b:outline:r:g:b");
5608                 }
5609                 else {
5610                   int delta = 0;
5611                   float er,eg,eb;
5612                   float nr,ng,nb;
5613                   vtkFloatingPointType otr,otg,otb;
5614                   //Old case backsurface color is independent
5615                   if( colors.count() == 16 ) {
5616                     QColor ffc;
5617                     SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
5618                     er = colors[9].toFloat();
5619                     eg = colors[10].toFloat();
5620                     eb = colors[11].toFloat();
5621
5622                     nr = colors[13].toFloat();
5623                     ng = colors[14].toFloat();
5624                     nb = colors[15].toFloat();
5625                     SMESH::GetColor("SMESH", "outline_color", otr, otg, otb, QColor( 0, 70, 0 ) );
5626                   } else {
5627                     //New case backsurface color depends on surface color
5628                     delta = colors[5].toInt();
5629
5630                     er = colors[7].toFloat();
5631                     eg = colors[8].toFloat();
5632                     eb = colors[9].toFloat();
5633
5634                     nr = colors[11].toFloat();
5635                     ng = colors[12].toFloat();
5636                     nb = colors[13].toFloat();
5637
5638                     otr = colors[15].toFloat();
5639                     otg = colors[16].toFloat();
5640                     otb = colors[17].toFloat();
5641                   }
5642                   aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat(), delta);
5643                   aSmeshActor->SetEdgeColor(er,eg,eb);
5644                   aSmeshActor->SetNodeColor(nr,ng,nb);
5645                   aSmeshActor->SetOutlineColor(otr,otg,otb);
5646                 }
5647               }
5648             }
5649             // Sizes of lines and points
5650             else if (paramNameStr == "Sizes") {
5651               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5652               if (sizes.count() == 4) {
5653                 if (sizes[0] != "line" || sizes[2] != "shrink") {
5654                   MESSAGE("Invalid order of data in Sizes, must be: "
5655                           "line:int:shrink:float");
5656                 }
5657                 else {
5658                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5659                   aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5660                 }
5661               }
5662               else if (sizes.count() == 6) { // just to support old format
5663                 if (sizes[0] != "line" || sizes[2]  != "node" || sizes[4] != "shrink") {
5664                   MESSAGE("Invalid order of data in Sizes, must be: "
5665                           "line:int:node:int:shrink:float");
5666                 }
5667                 else {
5668                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5669                   //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5670                   aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5671                 }
5672               }
5673             }
5674             // Point marker
5675             else if (paramNameStr == "PointMarker") {
5676               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5677               if( data.count() >= 2 ) {
5678                 bool ok = false;
5679                 int aParam1 = data[1].toInt( &ok );
5680                 if( ok ) {
5681                   if( data[0] == "std" && data.count() == 3 ) {
5682                     int aParam2 = data[2].toInt( &ok );
5683                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5684                   }
5685                   else if( data[0] == "custom" ) {
5686                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5687                     if( markerIt != aMarkerMap.end() ) {
5688                       VTK::MarkerData aMarkerData = markerIt->second;
5689                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5690                     }
5691                   }
5692                 }
5693               }
5694             }
5695             // Opacity
5696             else if (paramNameStr == "Opacity") {
5697               aSmeshActor->SetOpacity(val.toFloat());
5698             }
5699             // Clipping
5700             else if (paramNameStr.startsWith("ClippingPlane")) {
5701               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5702               // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5703               // new format - val looks like "Off" or "0" (plane id)
5704               // (note: in new format "Off" value is used only for consistency,
5705               //  so it is processed together with values in old format)
5706               bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5707               if( anIsOldFormat ) {
5708                 if (paramNameStr == "ClippingPlane1" || val == "Off")
5709                   aSmeshActor->RemoveAllClippingPlanes();
5710                 if (val != "Off") {
5711                   SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5712                   double aDistance = vals[1].toFloat();
5713                   vtkFloatingPointType anAngle[2];
5714                   anAngle[0] = vals[2].toFloat();
5715                   anAngle[1] = vals[3].toFloat();
5716
5717                   QList<SUIT_ViewManager*> lst;
5718                   getApp()->viewManagers(viewerTypStr, lst);
5719                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5720                   if (viewIndex >= 0 && viewIndex < lst.count()) {
5721                     SUIT_ViewManager* vman = lst.at(viewIndex);
5722                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5723
5724                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5725
5726                     SMESH::TActorList anActorList;
5727                     anActorList.push_back( aSmeshActor );
5728                     SMESH::OrientedPlane* aPlane =
5729                       SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5730                     if( aPlane ) {
5731                       SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5732                       aClippingPlaneInfo.Plane = aPlane;
5733                       aClippingPlaneInfo.ActorList = anActorList;
5734                       aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5735                     }
5736                   }
5737                 }
5738               }
5739               else {
5740                 bool ok = false;
5741                 int aPlaneId = val.toInt( &ok );
5742                 if( ok && aPlaneId >= 0 ) {
5743                   bool anIsDefinedPlane = false;
5744                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5745                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5746                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5747                     TPlaneInfo& aPlaneInfo = *anIter;
5748                     if( aPlaneInfo.PlaneId == aPlaneId ) {
5749                       aPlaneInfo.ActorList.push_back( aSmeshActor );
5750                       anIsDefinedPlane = true;
5751                       break;
5752                     }
5753                   }
5754                   if( !anIsDefinedPlane ) {
5755                     TPlaneInfo aPlaneInfo;
5756                     aPlaneInfo.PlaneId = aPlaneId;
5757                     aPlaneInfo.ActorList.push_back( aSmeshActor );
5758                     aPlaneInfo.ViewManager = vman;
5759
5760                     // to make the list sorted by plane id
5761                     anIter = aPlaneInfoList.begin();
5762                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5763                       const TPlaneInfo& aPlaneInfoRef = *anIter;
5764                       if( aPlaneInfoRef.PlaneId > aPlaneId )
5765                         break;
5766                     }
5767                     aPlaneInfoList.insert( anIter, aPlaneInfo );
5768                   }
5769                 }
5770               }
5771             }
5772           } // if (aSmeshActor)
5773         } // other parameters than Visibility
5774       }
5775     } // for names/parameters iterator
5776   } // for entries iterator
5777
5778   // take into account planes with empty list of actors referred to them
5779   QList<SUIT_ViewManager*> aVMList;
5780   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5781
5782   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5783   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5784     int aViewId = aPlaneDataIter->first;
5785     if( aViewId >= 0 && aViewId < aVMList.count() ) {
5786       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5787
5788       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5789
5790       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5791       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5792       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5793         const TPlaneData& aPlaneData = *anIter2;
5794         int aPlaneId = aPlaneData.Id;
5795
5796         bool anIsFound = false;
5797         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5798         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5799           const TPlaneInfo& aPlaneInfo = *anIter3;
5800           if( aPlaneInfo.PlaneId == aPlaneId ) {
5801             anIsFound = true;
5802             break;
5803           }
5804         }
5805
5806         if( !anIsFound ) {
5807           TPlaneInfo aPlaneInfo; // ActorList field is empty
5808           aPlaneInfo.PlaneId = aPlaneId;
5809           aPlaneInfo.ViewManager = aViewManager;
5810
5811           // to make the list sorted by plane id
5812           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5813           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5814             const TPlaneInfo& aPlaneInfoRef = *anIter4;
5815             if( aPlaneInfoRef.PlaneId > aPlaneId )
5816               break;
5817           }
5818           aPlaneInfoList.insert( anIter4, aPlaneInfo );
5819         }
5820       }
5821     }
5822   }
5823
5824   // add clipping planes to actors according to the restored parameters
5825   // and update the clipping plane map
5826   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5827   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5828     int aViewId = anIter1->first;
5829     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5830
5831     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5832     if( anIter2 == aPlaneDataMap.end() )
5833       continue;
5834     const TPlaneDataList& aPlaneDataList = anIter2->second;
5835
5836     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5837     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5838       const TPlaneInfo& aPlaneInfo = *anIter3;
5839       int aPlaneId = aPlaneInfo.PlaneId;
5840       const TActorList& anActorList = aPlaneInfo.ActorList;
5841       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5842       if( !aViewManager )
5843         continue;
5844
5845       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5846       if( !aViewWindow )
5847         continue;
5848
5849       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5850
5851       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5852       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5853         const TPlaneData& aPlaneData = *anIter4;
5854         if( aPlaneData.Id == aPlaneId ) {
5855           SMESH::OrientedPlane* aPlane =
5856             SMESHGUI_ClippingDlg::AddPlane( anActorList,
5857                                             aViewWindow,
5858                                             (SMESH::Orientation)aPlaneData.Orientation,
5859                                             aPlaneData.Distance,
5860                                             aPlaneData.Angle );
5861           if( aPlane ) {
5862             SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5863             aClippingPlaneInfo.Plane = aPlane;
5864             aClippingPlaneInfo.ActorList = anActorList;
5865             aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5866           }
5867           break;
5868         }
5869       }
5870     }
5871   }
5872
5873   // update all VTK views
5874   QList<SUIT_ViewManager*> lst;
5875   getApp()->viewManagers(lst);
5876   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5877     SUIT_ViewModel* vmodel = (*it)->getViewModel();
5878     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5879       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5880       vtkView->getRenderer()->ResetCameraClippingRange();
5881       vtkView->Repaint();
5882     }
5883   }
5884 }
5885
5886 /*!
5887   \brief Adds preferences for dfont of VTK viewer
5888   \param label label
5889   \param pIf group identifier
5890   \param param parameter
5891   \return identifier of preferences
5892 */
5893 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5894 {
5895   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5896
5897   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5898
5899   QStringList fam;
5900   fam.append( tr( "SMESH_FONT_ARIAL" ) );
5901   fam.append( tr( "SMESH_FONT_COURIER" ) );
5902   fam.append( tr( "SMESH_FONT_TIMES" ) );
5903
5904   setPreferenceProperty( tfont, "fonts", fam );
5905
5906   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5907   setPreferenceProperty( tfont, "features", f );
5908
5909   return tfont;
5910 }
5911
5912 /*!
5913   \brief Actions after hypothesis edition
5914   Updates object browser after hypothesis edition
5915 */
5916 void SMESHGUI::onHypothesisEdit( int result )
5917 {
5918   if( result == 1 )
5919     SMESHGUI::Modified();
5920   updateObjBrowser( true );
5921 }
5922
5923
5924 /*!
5925   \brief Signal handler closing(SUIT_ViewWindow*) of a view
5926   \param pview view being closed
5927 */
5928 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5929 #ifndef DISABLE_PLOT2DVIEWER
5930   //Crear all Plot2d Viewers if need.
5931   SMESH::ClearPlot2Viewers(pview);
5932 #endif
5933 }
5934
5935 /*!
5936   \brief Connects or disconnects signals about activating and cloning view on the module slots
5937   \param pview view which is connected/disconnected
5938 */
5939 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
5940   if(!pview)
5941     return;
5942
5943   SUIT_ViewManager* viewMgr = pview->getViewManager();
5944   if ( viewMgr ) {
5945     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5946                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5947
5948     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5949              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5950   }
5951 }
5952
5953 /*!
5954   \brief Return \c true if object can be renamed
5955 */
5956 bool SMESHGUI::renameAllowed( const QString& entry) const {
5957   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5958   if( !anApp )
5959     return false;
5960
5961   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5962   if( !aStudy )
5963     return false;
5964
5965   bool appRes = SalomeApp_Module::renameAllowed(entry);
5966   if( !appRes )
5967     return false;
5968
5969   // check type to prevent renaming of inappropriate objects
5970   int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
5971   if (aType == MESH || aType == GROUP ||
5972       aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5973       aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5974       aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5975       aType == HYPOTHESIS || aType == ALGORITHM)
5976     return true;
5977
5978   return false;
5979 }
5980
5981 /*!
5982   Rename object by entry.
5983   \param entry entry of the object
5984   \param name new name of the object
5985   \brief Return \c true if rename operation finished successfully, \c false otherwise.
5986 */
5987 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
5988
5989   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5990   if( !anApp )
5991     return false;
5992
5993   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5994   if( !aStudy )
5995     return false;
5996
5997   bool appRes = SalomeApp_Module::renameObject(entry,name);
5998   if( !appRes )
5999     return false;
6000
6001   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6002   _PTR(GenericAttribute) anAttr;
6003   _PTR(AttributeName) aName;
6004   if ( obj ) {
6005     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6006       aName = anAttr;
6007       // check type to prevent renaming of inappropriate objects
6008       int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
6009       if (aType == MESH || aType == GROUP ||
6010           aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6011           aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6012           aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6013           aType == HYPOTHESIS || aType == ALGORITHM) {
6014         if ( !name.isEmpty() ) {
6015           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6016
6017           // update name of group object and its actor
6018           Handle(SALOME_InteractiveObject) IObject =
6019             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6020
6021           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6022           if( !aGroupObject->_is_nil() ) {
6023             aGroupObject->SetName( qPrintable(name) );
6024             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6025               anActor->setName( qPrintable(name) );
6026           }
6027           return true;
6028         }
6029       }
6030     }
6031   }
6032   return false;
6033 }