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
4490   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4491   setPreferenceProperty( dispgroup, "columns", 2 );
4492   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4493   QStringList modes;
4494   modes.append( tr("MEN_WIRE") );
4495   modes.append( tr("MEN_SHADE") );
4496   modes.append( tr("MEN_NODES") );
4497   modes.append( tr("MEN_SHRINK") );
4498   QList<QVariant> indices;
4499   indices.append( 0 );
4500   indices.append( 1 );
4501   indices.append( 2 );
4502   indices.append( 3 );
4503   setPreferenceProperty( dispmode, "strings", modes );
4504   setPreferenceProperty( dispmode, "indexes", indices );
4505
4506   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4507   setPreferenceProperty( arcgroup, "columns", 2 );
4508   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4509   QStringList quadraticModes;
4510   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4511   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4512   indices.clear();
4513   indices.append( 0 );
4514   indices.append( 1 );
4515   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4516   setPreferenceProperty( quadraticmode, "indexes", indices );
4517
4518   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4519                               "SMESH", "max_angle" );
4520   setPreferenceProperty( maxAngle, "min", 1 );
4521   setPreferenceProperty( maxAngle, "max", 90 );
4522
4523
4524
4525   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4526   setPreferenceProperty( exportgroup, "columns", 2 );
4527   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4528   addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4529
4530   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4531   setPreferenceProperty( computeGroup, "columns", 2 );
4532   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4533   modes.clear();
4534   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4535   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4536   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4537   indices.clear();
4538   indices.append( 0 );
4539   indices.append( 1 );
4540   indices.append( 2 );
4541   setPreferenceProperty( notifyMode, "strings", modes );
4542   setPreferenceProperty( notifyMode, "indexes", indices );
4543
4544   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4545   setPreferenceProperty( infoGroup, "columns", 4 );
4546   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4547   modes.clear();
4548   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4549   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4550   indices.clear();
4551   indices.append( 0 );
4552   indices.append( 1 );
4553   setPreferenceProperty( elemInfo, "strings", modes );
4554   setPreferenceProperty( elemInfo, "indexes", indices );
4555   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4556   setPreferenceProperty( nodesLim, "min", 0 );
4557   setPreferenceProperty( nodesLim, "max", 10000000 );
4558   setPreferenceProperty( nodesLim, "step", 10000 );
4559   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4560
4561   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4562   setPreferenceProperty( segGroup, "columns", 2 );
4563   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4564                               "SMESH", "segmentation" );
4565   setPreferenceProperty( segLen, "min", 1 );
4566   setPreferenceProperty( segLen, "max", 10000000 );
4567   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4568                              "SMESH", "nb_segments_per_edge" );
4569   setPreferenceProperty( nbSeg, "min", 1 );
4570   setPreferenceProperty( nbSeg, "max", 10000000 );
4571
4572   // Quantities with individual precision settings
4573   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4574   setPreferenceProperty( precGroup, "columns", 2 );
4575
4576   const int nbQuantities = 6;
4577   int precs[nbQuantities], ii = 0;
4578   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4579                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4580   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4581                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4582   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4583                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4584   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4585                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4586   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4587                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4588   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4589                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4590
4591   // Set property for precision value for spinboxes
4592   for ( ii = 0; ii < nbQuantities; ii++ ){
4593     setPreferenceProperty( precs[ii], "min", -14 );
4594     setPreferenceProperty( precs[ii], "max", 14 );
4595     setPreferenceProperty( precs[ii], "precision", 2 );
4596   }
4597
4598   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4599   setPreferenceProperty( previewGroup, "columns", 2 );
4600   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4601   setPreferenceProperty( chunkSize, "min",  0 );
4602   setPreferenceProperty( chunkSize, "max",  1000 );
4603   setPreferenceProperty( chunkSize, "step", 50 );
4604
4605   // Mesh tab ------------------------------------------------------------------------
4606   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4607   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4608   setPreferenceProperty( nodeGroup, "columns", 3 );
4609
4610   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4611
4612   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4613
4614   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4615   QList<QVariant> aMarkerTypeIndicesList;
4616   QList<QVariant> aMarkerTypeIconsList;
4617   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4618     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4619     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4620     aMarkerTypeIndicesList << i;
4621     aMarkerTypeIconsList << pixmap;
4622   }
4623   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4624   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
4625
4626   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4627
4628   QList<QVariant> aMarkerScaleIndicesList;
4629   QStringList     aMarkerScaleValuesList;
4630   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4631     aMarkerScaleIndicesList << i;
4632     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4633   }
4634   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4635   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4636
4637   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4638   setPreferenceProperty( elemGroup, "columns", 2 );
4639
4640   int ColorId = addPreference( tr( "PREF_FILL"     ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4641   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4642
4643   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4644   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4645
4646   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4647
4648   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4649   setPreferenceProperty( grpGroup, "columns", 2 );
4650
4651   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4652
4653   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4654                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4655   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
4656                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
4657   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4658                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4659
4660   setPreferenceProperty( size0d, "min", 1 );
4661   setPreferenceProperty( size0d, "max", 10 );
4662
4663   setPreferenceProperty( elemW, "min", 1 );
4664   setPreferenceProperty( elemW, "max", 5 );
4665
4666   setPreferenceProperty( shrink, "min", 0 );
4667   setPreferenceProperty( shrink, "max", 100 );
4668
4669   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4670   setPreferenceProperty( orientGroup, "columns", 1 );
4671
4672   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4673   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4674
4675   setPreferenceProperty( orientScale, "min", 0.05 );
4676   setPreferenceProperty( orientScale, "max", 0.5 );
4677   setPreferenceProperty( orientScale, "step", 0.05 );
4678
4679   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4680
4681   // Selection tab ------------------------------------------------------------------------
4682   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4683
4684   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4685   setPreferenceProperty( selGroup, "columns", 2 );
4686
4687   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4688   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4689   int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" );
4690
4691   setPreferenceProperty( selW, "min", 1 );
4692   setPreferenceProperty( selW, "max", 5 );
4693
4694   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4695   setPreferenceProperty( preGroup, "columns", 2 );
4696
4697   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4698   int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" );
4699
4700   setPreferenceProperty( preW, "min", 1 );
4701   setPreferenceProperty( preW, "max", 5 );
4702
4703   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4704   setPreferenceProperty( precSelGroup, "columns", 2 );
4705
4706   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4707   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4708   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4709
4710   // Scalar Bar tab ------------------------------------------------------------------------
4711   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4712   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4713   setPreferenceProperty( fontGr, "columns", 2 );
4714
4715   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4716   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4717
4718   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4719   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4720
4721   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4722   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4723
4724   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4725   setPreferenceProperty( numcol, "min", 2 );
4726   setPreferenceProperty( numcol, "max", 256 );
4727
4728   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4729   setPreferenceProperty( numlab, "min", 2 );
4730   setPreferenceProperty( numlab, "max", 65 );
4731
4732   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4733   setPreferenceProperty( orientGr, "columns", 2 );
4734   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4735   QStringList orients;
4736   orients.append( tr( "SMESH_VERTICAL" ) );
4737   orients.append( tr( "SMESH_HORIZONTAL" ) );
4738   indices.clear(); indices.append( 0 ); indices.append( 1 );
4739   setPreferenceProperty( orient, "strings", orients );
4740   setPreferenceProperty( orient, "indexes", indices );
4741
4742   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4743   setPreferenceProperty( posVSizeGr, "columns", 2 );
4744   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4745   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4746   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4747   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4748   setPreferenceProperty( xv, "step", 0.1 );
4749   setPreferenceProperty( xv, "min", 0.0 );
4750   setPreferenceProperty( xv, "max", 1.0 );
4751   setPreferenceProperty( yv, "step", 0.1 );
4752   setPreferenceProperty( yv, "min", 0.0 );
4753   setPreferenceProperty( yv, "max", 1.0 );
4754   setPreferenceProperty( wv, "step", 0.1 );
4755   setPreferenceProperty( wv, "min", 0.0 );
4756   setPreferenceProperty( wv, "max", 1.0 );
4757   setPreferenceProperty( hv, "min", 0.0 );
4758   setPreferenceProperty( hv, "max", 1.0 );
4759   setPreferenceProperty( hv, "step", 0.1 );
4760
4761   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4762   setPreferenceProperty( posHSizeGr, "columns", 2 );
4763   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4764   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4765   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4766   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4767   setPreferenceProperty( xv, "min", 0.0 );
4768   setPreferenceProperty( xv, "max", 1.0 );
4769   setPreferenceProperty( xv, "step", 0.1 );
4770   setPreferenceProperty( xh, "min", 0.0 );
4771   setPreferenceProperty( xh, "max", 1.0 );
4772   setPreferenceProperty( xh, "step", 0.1 );
4773   setPreferenceProperty( yh, "min", 0.0 );
4774   setPreferenceProperty( yh, "max", 1.0 );
4775   setPreferenceProperty( yh, "step", 0.1 );
4776   setPreferenceProperty( wh, "min", 0.0 );
4777   setPreferenceProperty( wh, "max", 1.0 );
4778   setPreferenceProperty( wh, "step", 0.1 );
4779   setPreferenceProperty( hh, "min", 0.0 );
4780   setPreferenceProperty( hh, "max", 1.0 );
4781   setPreferenceProperty( hh, "step", 0.1 );
4782
4783   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4784   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4785   setPreferenceProperty( distributionGr, "columns", 3 );
4786   QStringList types;
4787   types.append( tr( "SMESH_MONOCOLOR" ) );
4788   types.append( tr( "SMESH_MULTICOLOR" ) );
4789   indices.clear(); indices.append( 0 ); indices.append( 1 );
4790   setPreferenceProperty( coloringType, "strings", types );
4791   setPreferenceProperty( coloringType, "indexes", indices );
4792   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4793
4794 }
4795
4796 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4797 {
4798   if( sect=="SMESH" ) {
4799     float sbX1,sbY1,sbW,sbH;
4800     float aTol = 1.00000009999999;
4801     std::string aWarning;
4802     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4803     if( name=="selection_object_color" || name=="selection_element_color" ||
4804         name=="selection_width" || name=="highlight_color" || name=="highlight_width" ||
4805         name=="selection_precision_node" || name=="selection_precision_element" ||
4806         name=="selection_precision_object")
4807       SMESH::UpdateSelectionProp( this );
4808     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4809       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4810       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4811       if(sbX1+sbW > aTol){
4812         aWarning = "Origin and Size Vertical: X+Width > 1\n";
4813         sbX1=0.01;
4814         sbW=0.08;
4815         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4816         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4817       }
4818     }
4819     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4820       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4821       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4822       if(sbY1+sbH > aTol){
4823         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4824         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4825         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4826       }
4827     }
4828     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
4829       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4830       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4831       if(sbX1+sbW > aTol){
4832         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4833         sbX1=0.1;
4834         sbW=0.08;
4835         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4836         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4837       }
4838     }
4839     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
4840       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4841       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4842       if(sbY1+sbH > aTol){
4843         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4844         sbY1=0.01;
4845         sbH=0.08;
4846         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4847         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4848       }
4849     }
4850     else if ( name == "segmentation" ) {
4851       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4852       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4853     }
4854     else if ( name == "nb_segments_per_edge" ) {
4855       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4856       myComponentSMESH->SetDefaultNbSegments( nbSeg );
4857     }
4858
4859     if(aWarning.size() != 0){
4860       aWarning += "The default values are applied instead.";
4861       SUIT_MessageBox::warning(SMESHGUI::desktop(),
4862                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4863                                QObject::tr(aWarning.c_str()));
4864     }
4865   }
4866 }
4867
4868 //================================================================================
4869 /*!
4870  * \brief Update something in accordance with update flags
4871   * \param theFlags - update flags
4872 *
4873 * Update viewer or/and object browser etc. in accordance with update flags ( see
4874 * LightApp_UpdateFlags enumeration ).
4875 */
4876 //================================================================================
4877 void SMESHGUI::update( const int flags )
4878 {
4879   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4880     SMESH::UpdateView();
4881   else
4882     SalomeApp_Module::update( flags );
4883 }
4884
4885 //================================================================================
4886 /*!
4887  * \brief Set default selection mode
4888 *
4889 * SLOT called when operation commited. Sets default selection mode
4890 */
4891 //================================================================================
4892 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4893 {
4894   SVTK_ViewWindow* vtkWnd =
4895     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4896   if ( vtkWnd )
4897     vtkWnd->SetSelectionMode( ActorSelection );
4898 }
4899
4900 //================================================================================
4901 /*!
4902  * \brief Set default selection mode
4903 *
4904 * SLOT called when operation aborted. Sets default selection mode
4905 */
4906 //================================================================================
4907 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4908 {
4909   SVTK_ViewWindow* vtkWnd =
4910     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4911   if ( vtkWnd )
4912     vtkWnd->SetSelectionMode( ActorSelection );
4913 }
4914
4915 //================================================================================
4916 /*!
4917  * \brief Creates operation with given identifier
4918   * \param id - identifier of operation to be started
4919   * \return Pointer on created operation or NULL if operation is not created
4920 *
4921 * Virtual method redefined from the base class creates operation with given id.
4922 * It is called called automatically from startOperation method of base class.
4923 */
4924 //================================================================================
4925 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4926 {
4927   LightApp_Operation* op = 0;
4928   // to do : create operation here
4929   switch( id )
4930   {
4931     case 417: //convert to quadratic
4932       op = new SMESHGUI_ConvToQuadOp();
4933     break;
4934     case 418: // create 2D mesh as boundary on 3D
4935       op = new SMESHGUI_Make2DFrom3DOp();
4936     break;
4937     case 701: // Compute mesh
4938       op = new SMESHGUI_ComputeOp();
4939     break;
4940     case 702: // Create mesh
4941       op = new SMESHGUI_MeshOp( true, true );
4942     break;
4943     case 703: // Create sub-mesh
4944       op = new SMESHGUI_MeshOp( true, false );
4945     break;
4946     case 704: // Edit mesh/sub-mesh
4947       op = new SMESHGUI_MeshOp( false );
4948     break;
4949     case 711: // Precompute mesh
4950       op = new SMESHGUI_PrecomputeOp();
4951     break;
4952     case 712: // Evaluate mesh
4953       op = new SMESHGUI_EvaluateOp();
4954     break;
4955     case 713: // Evaluate mesh
4956       op = new SMESHGUI_MeshOrderOp();
4957     break;
4958     case 806: // Create group on geom
4959       op = new SMESHGUI_GroupOnShapeOp();
4960       break;
4961     case 904: // Find element
4962       op = new SMESHGUI_FindElemByPointOp();
4963       break;
4964     case 4067: // make mesh pass through point
4965       op = new SMESHGUI_MakeNodeAtPointOp();
4966       break;
4967     default:
4968     break;
4969   }
4970
4971   if( !op )
4972     op = SalomeApp_Module::createOperation( id );
4973   return op;
4974 }
4975
4976 //================================================================================
4977 /*!
4978  * \brief Stops current operations and starts a given one
4979   * \param id - The id of the operation to start
4980  */
4981 //================================================================================
4982
4983 void SMESHGUI::switchToOperation(int id)
4984 {
4985   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
4986     activeStudy()->abortAllOperations();
4987   startOperation( id );
4988 }
4989
4990 LightApp_Displayer* SMESHGUI::displayer()
4991 {
4992   if( !myDisplayer )
4993     myDisplayer = new SMESHGUI_Displayer( getApp() );
4994   return myDisplayer;
4995 }
4996
4997 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
4998 {
4999   int aHue = -1;
5000   int aTolerance = 64;
5001   int anIterations = 0;
5002   int aPeriod = 5;
5003
5004   while( 1 )
5005   {
5006     anIterations++;
5007     if( anIterations % aPeriod == 0 )
5008     {
5009       aTolerance /= 2;
5010       if( aTolerance < 1 )
5011         break;
5012     }
5013
5014     aHue = (int)( 360.0 * rand() / RAND_MAX );
5015
5016     bool ok = true;
5017     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5018     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5019     for( ; it != itEnd; ++it )
5020     {
5021       SALOMEDS::Color anAutoColor = *it;
5022       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5023
5024       int h, s, v;
5025       aQColor.getHsv( &h, &s, &v );
5026       if( abs( h - aHue ) < aTolerance )
5027       {
5028         ok = false;
5029         break;
5030       }
5031     }
5032
5033     if( ok )
5034       break;
5035   }
5036
5037   QColor aColor;
5038   aColor.setHsv( aHue, 255, 255 );
5039
5040   SALOMEDS::Color aSColor;
5041   aSColor.R = (double)aColor.red() / 255.0;
5042   aSColor.G = (double)aColor.green() / 255.0;
5043   aSColor.B = (double)aColor.blue() / 255.0;
5044
5045   return aSColor;
5046 }
5047
5048 const char gSeparator = '_'; // character used to separate parameter names
5049 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
5050 const char gPathSep   = '|'; // character used to separate paths
5051
5052 /*!
5053  * \brief Store visual parameters
5054  *
5055  * This method is called just before the study document is saved.
5056  * Store visual parameters in AttributeParameter attribue(s)
5057  */
5058 void SMESHGUI::storeVisualParameters (int savePoint)
5059 {
5060   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5061   if (!appStudy || !appStudy->studyDS())
5062     return;
5063   _PTR(Study) studyDS = appStudy->studyDS();
5064
5065   // componentName is used for encoding of entries when storing them in IParameters
5066   std::string componentName = myComponentSMESH->ComponentDataType();
5067   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5068   //if (!aSComponent) return;
5069
5070   // IParameters
5071   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5072                                                              componentName.c_str(),
5073                                                              savePoint);
5074   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5075
5076   // store map of custom markers
5077   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5078   if( !aMarkerMap.empty() )
5079   {
5080     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5081     for( ; anIter != aMarkerMap.end(); anIter++ )
5082     {
5083       int anId = anIter->first;
5084       VTK::MarkerData aMarkerData = anIter->second;
5085       std::string aMarkerFileName = aMarkerData.first;
5086       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5087       if( aMarkerTexture.size() < 3 )
5088         continue; // should contain at least width, height and the first value
5089
5090       QString aPropertyName( "texture" );
5091       aPropertyName += gSeparator;
5092       aPropertyName += QString::number( anId );
5093
5094       QString aPropertyValue = aMarkerFileName.c_str();
5095       aPropertyValue += gPathSep;
5096
5097       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5098       ushort aWidth = *aTextureIter++;
5099       ushort aHeight = *aTextureIter++;
5100       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5101       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5102       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5103         aPropertyValue += QString::number( *aTextureIter );
5104
5105       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5106     }
5107   }
5108
5109   // viewers counters are used for storing view_numbers in IParameters
5110   int vtkViewers = 0;
5111
5112   // main cycle to store parameters of displayed objects
5113   QList<SUIT_ViewManager*> lst;
5114   QList<SUIT_ViewManager*>::Iterator it;
5115   getApp()->viewManagers(lst);
5116   for (it = lst.begin(); it != lst.end(); it++)
5117   {
5118     SUIT_ViewManager* vman = *it;
5119     QString vType = vman->getType();
5120
5121     // saving VTK actors properties
5122     if (vType == SVTK_Viewer::Type())
5123     {
5124       // store the clipping planes attached to the view manager
5125       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5126       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5127       if( anIter != myClippingPlaneInfoMap.end() )
5128         aClippingPlaneInfoList = anIter->second;
5129
5130       if( !aClippingPlaneInfoList.empty() ) {
5131         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5132         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5133         {
5134           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5135           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5136
5137           QString aPropertyName( "ClippingPlane" );
5138           aPropertyName += gSeparator;
5139           aPropertyName += QString::number( vtkViewers );
5140           aPropertyName += gSeparator;
5141           aPropertyName += QString::number( anId );
5142
5143           QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5144           aPropertyValue += gDigitsSep;
5145           aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5146           aPropertyValue += gDigitsSep;
5147           aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5148           aPropertyValue += gDigitsSep;
5149           aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5150
5151           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5152         }
5153       }
5154
5155       QVector<SUIT_ViewWindow*> views = vman->getViews();
5156       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5157       {
5158         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5159         {
5160           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5161           vtkActorCollection* allActors = aCopy.GetActors();
5162           allActors->InitTraversal();
5163           while (vtkActor* actor = allActors->GetNextActor())
5164           {
5165             if (actor->GetVisibility()) // store only visible actors
5166             {
5167               SMESH_Actor* aSmeshActor = 0;
5168               if (actor->IsA("SMESH_Actor"))
5169                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5170               if (aSmeshActor && aSmeshActor->hasIO())
5171               {
5172                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5173                 if (io->hasEntry())
5174                 {
5175                   // entry is "encoded" = it does NOT contain component adress,
5176                   // since it is a subject to change on next component loading
5177                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5178
5179                   std::string param, vtkParam = vType.toLatin1().data();
5180                   vtkParam += gSeparator;
5181                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5182                   vtkParam += gSeparator;
5183
5184                   // Visibility
5185                   param = vtkParam + "Visibility";
5186                   ip->setParameter(entry, param, "On");
5187
5188                   // Representation
5189                   param = vtkParam + "Representation";
5190                   ip->setParameter(entry, param, QString::number
5191                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5192
5193                   // IsShrunk
5194                   param = vtkParam + "IsShrunk";
5195                   ip->setParameter(entry, param, QString::number
5196                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5197
5198                   // Displayed entities
5199                   unsigned int aMode = aSmeshActor->GetEntityMode();
5200                   bool isE = aMode & SMESH_Actor::eEdges;
5201                   bool isF = aMode & SMESH_Actor::eFaces;
5202                   bool isV = aMode & SMESH_Actor::eVolumes;
5203
5204                   QString modeStr ("e");
5205                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5206                   modeStr += gDigitsSep; modeStr += "f";
5207                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5208                   modeStr += gDigitsSep; modeStr += "v";
5209                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5210
5211                   param = vtkParam + "Entities";
5212                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5213
5214                   // Colors (surface:edge:)
5215                   vtkFloatingPointType r, g, b;
5216                   int delta;
5217
5218                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5219                   QString colorStr ("surface");
5220                   colorStr += gDigitsSep; colorStr += QString::number(r);
5221                   colorStr += gDigitsSep; colorStr += QString::number(g);
5222                   colorStr += gDigitsSep; colorStr += QString::number(b);
5223
5224                   colorStr += gDigitsSep; colorStr += "backsurface";
5225                   colorStr += gDigitsSep; colorStr += QString::number(delta);
5226
5227
5228                   aSmeshActor->GetEdgeColor(r, g, b);
5229                   colorStr += gDigitsSep; colorStr += "edge";
5230                   colorStr += gDigitsSep; colorStr += QString::number(r);
5231                   colorStr += gDigitsSep; colorStr += QString::number(g);
5232                   colorStr += gDigitsSep; colorStr += QString::number(b);
5233
5234                   aSmeshActor->GetNodeColor(r, g, b);
5235                   colorStr += gDigitsSep; colorStr += "node";
5236                   colorStr += gDigitsSep; colorStr += QString::number(r);
5237                   colorStr += gDigitsSep; colorStr += QString::number(g);
5238                   colorStr += gDigitsSep; colorStr += QString::number(b);
5239
5240                   aSmeshActor->GetOutlineColor(r, g, b);
5241                   colorStr += gDigitsSep; colorStr += "outline";
5242                   colorStr += gDigitsSep; colorStr += QString::number(r);
5243                   colorStr += gDigitsSep; colorStr += QString::number(g);
5244                   colorStr += gDigitsSep; colorStr += QString::number(b);
5245
5246                   param = vtkParam + "Colors";
5247                   ip->setParameter(entry, param, colorStr.toLatin1().data());
5248
5249                   // Sizes of lines and points
5250                   QString sizeStr ("line");
5251                   sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5252                   sizeStr += gDigitsSep; sizeStr += "shrink";
5253                   sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5254
5255                   param = vtkParam + "Sizes";
5256                   ip->setParameter(entry, param, sizeStr.toLatin1().data());
5257
5258                   // Point marker
5259                   QString markerStr;
5260
5261                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5262                   if( aMarkerType == VTK::MT_USER ) {
5263                     markerStr += "custom";
5264                     markerStr += gDigitsSep;
5265                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5266                   }
5267                   else {
5268                     markerStr += "std";
5269                     markerStr += gDigitsSep;
5270                     markerStr += QString::number( (int)aMarkerType );
5271                     markerStr += gDigitsSep;
5272                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5273                   }
5274
5275                   param = vtkParam + "PointMarker";
5276                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5277
5278                   // Opacity
5279                   param = vtkParam + "Opacity";
5280                   ip->setParameter(entry, param,
5281                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5282
5283                   // Clipping
5284                   param = vtkParam + "ClippingPlane";
5285                   int aPlaneId = 0;
5286                   if( !aClippingPlaneInfoList.empty() ) {
5287                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5288                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5289                     {
5290                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5291                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5292                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5293                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5294                         if( aSmeshActor == *anIter2 ) {
5295                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5296                                             QString::number( anId ).toLatin1().constData() );
5297                           break;
5298                         }
5299                       }
5300                     }
5301                   }
5302                   if( aPlaneId == 0 )
5303                     ip->setParameter( entry, param, "Off" );
5304                 } // if (io->hasEntry())
5305               } // SMESH_Actor && hasIO
5306             } // isVisible
5307           } // while.. actors traversal
5308         } // if (vtkView)
5309       } // for (views)
5310       vtkViewers++;
5311     } // if (SVTK view model)
5312   } // for (viewManagers)
5313 }
5314
5315 // data structures for clipping planes processing
5316 typedef struct {
5317   int Id;
5318   vtkIdType Orientation;
5319   vtkFloatingPointType Distance;
5320   vtkFloatingPointType Angle[2];
5321 } TPlaneData;
5322 typedef std::list<TPlaneData>         TPlaneDataList;
5323 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5324
5325 typedef std::list<vtkActor*>          TActorList;
5326 typedef struct {
5327   int PlaneId;
5328   TActorList ActorList;
5329   SUIT_ViewManager* ViewManager;
5330 } TPlaneInfo;
5331 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5332 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5333
5334 /*!
5335  * \brief Restore visual parameters
5336  *
5337  * This method is called after the study document is opened.
5338  * Restore visual parameters from AttributeParameter attribue(s)
5339  */
5340 void SMESHGUI::restoreVisualParameters (int savePoint)
5341 {
5342   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5343   if (!appStudy || !appStudy->studyDS())
5344     return;
5345   _PTR(Study) studyDS = appStudy->studyDS();
5346
5347   // componentName is used for encoding of entries when storing them in IParameters
5348   std::string componentName = myComponentSMESH->ComponentDataType();
5349   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5350   //if (!aSComponent) return;
5351
5352   // IParameters
5353   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5354                                                              componentName.c_str(),
5355                                                              savePoint);
5356   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5357
5358   // restore map of custom markers and map of clipping planes
5359   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5360   TPlaneDataMap aPlaneDataMap;
5361
5362   std::vector<std::string> properties = ip->getProperties();
5363   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5364   {
5365     std::string property = *propIt;
5366     QString aPropertyName( property.c_str() );
5367     QString aPropertyValue( ip->getProperty( property ).c_str() );
5368
5369     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5370     if( aPropertyNameList.isEmpty() )
5371       continue;
5372
5373     QString aPropertyType = aPropertyNameList[0];
5374     if( aPropertyType == "texture" )
5375     {
5376       if( aPropertyNameList.size() != 2 )
5377         continue;
5378
5379       bool ok = false;
5380       int anId = aPropertyNameList[1].toInt( &ok );
5381       if( !ok || anId < 1 )
5382         continue;
5383
5384       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5385       if( aPropertyValueList.size() != 2 )
5386         continue;
5387
5388       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5389       QString aMarkerTextureString = aPropertyValueList[1];
5390       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5391       if( aMarkerTextureStringList.size() != 3 )
5392         continue;
5393
5394       ok = false;
5395       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5396       if( !ok )
5397         continue;
5398
5399       ok = false;
5400       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5401       if( !ok )
5402         continue;
5403
5404       VTK::MarkerTexture aMarkerTexture;
5405       aMarkerTexture.push_back( aWidth );
5406       aMarkerTexture.push_back( aHeight );
5407
5408       QString aMarkerTextureData = aMarkerTextureStringList[2];
5409       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5410       {
5411         QChar aChar = aMarkerTextureData.at( i );
5412         if( aChar.isDigit() )
5413           aMarkerTexture.push_back( aChar.digitValue() );
5414       }
5415
5416       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5417     }
5418     else if( aPropertyType == "ClippingPlane" )
5419     {
5420       if( aPropertyNameList.size() != 3 )
5421         continue;
5422
5423       bool ok = false;
5424       int aViewId = aPropertyNameList[1].toInt( &ok );
5425       if( !ok || aViewId < 0 )
5426         continue;
5427
5428       ok = false;
5429       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5430       if( !ok || aClippingPlaneId < 0 )
5431         continue;
5432
5433       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5434       if( aPropertyValueList.size() != 4 )
5435         continue;
5436
5437       TPlaneData aPlaneData;
5438       aPlaneData.Id = aClippingPlaneId;
5439
5440       ok = false;
5441       aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5442       if( !ok )
5443         continue;
5444
5445       ok = false;
5446       aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5447       if( !ok )
5448         continue;
5449
5450       ok = false;
5451       aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5452       if( !ok )
5453         continue;
5454
5455       ok = false;
5456       aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5457       if( !ok )
5458         continue;
5459
5460       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5461       aPlaneDataList.push_back( aPlaneData );
5462     }
5463   }
5464
5465   TPlaneInfoMap aPlaneInfoMap;
5466
5467   std::vector<std::string> entries = ip->getEntries();
5468
5469   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5470   {
5471     // entry is a normal entry - it should be "decoded" (setting base adress of component)
5472     QString entry (ip->decodeEntry(*entIt).c_str());
5473
5474     // Check that the entry corresponds to a real object in the Study
5475     // as the object may be deleted or modified after the visual state is saved.
5476     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5477     if (!so) continue; //Skip the not existent entry
5478
5479     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5480     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5481
5482     std::vector<std::string>::iterator namesIt = paramNames.begin();
5483     std::vector<std::string>::iterator valuesIt = paramValues.begin();
5484
5485     // actors are stored in a map after displaying of them for
5486     // quicker access in the future: map < viewID to actor >
5487     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5488
5489     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5490     {
5491       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5492       // '_' is used as separator and should not be used in viewer type or parameter names.
5493       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5494       if (lst.size() != 3)
5495         continue;
5496
5497       QString viewerTypStr = lst[0];
5498       QString viewIndexStr = lst[1];
5499       QString paramNameStr = lst[2];
5500
5501       bool ok;
5502       int viewIndex = viewIndexStr.toUInt(&ok);
5503       if (!ok) // bad conversion of view index to integer
5504         continue;
5505
5506       // viewers
5507       if (viewerTypStr == SVTK_Viewer::Type())
5508       {
5509         SMESH_Actor* aSmeshActor = 0;
5510         if (vtkActors.IsBound(viewIndex))
5511           aSmeshActor = vtkActors.Find(viewIndex);
5512
5513         QList<SUIT_ViewManager*> lst;
5514         getApp()->viewManagers(viewerTypStr, lst);
5515
5516         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5517         SUIT_ViewManager* vman = NULL;
5518         if (viewIndex >= 0 && viewIndex < lst.count())
5519           vman = lst.at(viewIndex);
5520
5521         if (paramNameStr == "Visibility")
5522         {
5523           if (!aSmeshActor && displayer() && vman)
5524           {
5525             SUIT_ViewModel* vmodel = vman->getViewModel();
5526             // SVTK view model can be casted to SALOME_View
5527             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5528
5529             // store displayed actor in a temporary map for quicker
5530             // access later when restoring other parameters
5531             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5532             vtkRenderer* Renderer = vtkView->getRenderer();
5533             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5534             vtkActorCollection* theActors = aCopy.GetActors();
5535             theActors->InitTraversal();
5536             bool isFound = false;
5537             vtkActor *ac = theActors->GetNextActor();
5538             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5539               if (ac->IsA("SMESH_Actor")) {
5540                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5541                 if (aGeomAc->hasIO()) {
5542                   Handle(SALOME_InteractiveObject) io =
5543                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5544                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5545                     isFound = true;
5546                     vtkActors.Bind(viewIndex, aGeomAc);
5547                   }
5548                 }
5549               }
5550             }
5551           }
5552         } // if (paramNameStr == "Visibility")
5553         else
5554         {
5555           // the rest properties "work" with SMESH_Actor
5556           if (aSmeshActor)
5557           {
5558             QString val ((*valuesIt).c_str());
5559
5560             // Representation
5561             if (paramNameStr == "Representation") {
5562               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5563             }
5564             // IsShrunk
5565             else if (paramNameStr == "IsShrunk") {
5566               if (val.toInt()) {
5567                 if (!aSmeshActor->IsShrunk())
5568                   aSmeshActor->SetShrink();
5569               }
5570               else {
5571                 if (aSmeshActor->IsShrunk())
5572                   aSmeshActor->UnShrink();
5573               }
5574             }
5575             // Displayed entities
5576             else if (paramNameStr == "Entities") {
5577               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5578               if (mode.count() == 6) {
5579                 if (mode[0] != "e" || mode[2]  != "f" || mode[4] != "v") {
5580                   MESSAGE("Invalid order of data in Entities, must be: "
5581                           "e:0/1:f:0/1:v:0/1");
5582                 }
5583                 else {
5584                   unsigned int aMode = aSmeshActor->GetEntityMode();
5585                   unsigned int aNewMode =
5586                     (int(SMESH_Actor::eEdges  ) * mode[1].toInt()) |
5587                     (int(SMESH_Actor::eFaces  ) * mode[3].toInt()) |
5588                     (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5589                   if (aNewMode != aMode)
5590                     aSmeshActor->SetEntityMode(aNewMode);
5591                 }
5592               }
5593             }
5594             // Colors
5595             else if (paramNameStr == "Colors") {
5596               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5597               if (colors.count() == 16 || colors.count() == 18 ) {
5598                 if (colors[0] != "surface" || colors[4]  != "backsurface" ||
5599                     (colors[8] != "edge" && colors[6] != "edge" ) || (colors[12] != "node" && colors[10] != "node") ||
5600                     (colors.count() == 18 && colors[14] != "outline")) {
5601                   MESSAGE("Invalid order of data in Colors, must be: "
5602                           "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");
5603                 }
5604                 else {
5605                   int delta = 0;
5606                   float er,eg,eb;
5607                   float nr,ng,nb;
5608                   vtkFloatingPointType otr,otg,otb;
5609                   //Old case backsurface color is independent
5610                   if( colors.count() == 16 ) {
5611                     QColor ffc;
5612                     SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
5613                     er = colors[9].toFloat();
5614                     eg = colors[10].toFloat();
5615                     eb = colors[11].toFloat();
5616
5617                     nr = colors[13].toFloat();
5618                     ng = colors[14].toFloat();
5619                     nb = colors[15].toFloat();
5620                     SMESH::GetColor("SMESH", "outline_color", otr, otg, otb, QColor( 0, 70, 0 ) );
5621                   } else {
5622                     //New case backsurface color depends on surface color
5623                     delta = colors[5].toInt();
5624
5625                     er = colors[7].toFloat();
5626                     eg = colors[8].toFloat();
5627                     eb = colors[9].toFloat();
5628
5629                     nr = colors[11].toFloat();
5630                     ng = colors[12].toFloat();
5631                     nb = colors[13].toFloat();
5632
5633                     otr = colors[15].toFloat();
5634                     otg = colors[16].toFloat();
5635                     otb = colors[17].toFloat();
5636                   }
5637                   aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat(), delta);
5638                   aSmeshActor->SetEdgeColor(er,eg,eb);
5639                   aSmeshActor->SetNodeColor(nr,ng,nb);
5640                   aSmeshActor->SetOutlineColor(otr,otg,otb);
5641                 }
5642               }
5643             }
5644             // Sizes of lines and points
5645             else if (paramNameStr == "Sizes") {
5646               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5647               if (sizes.count() == 4) {
5648                 if (sizes[0] != "line" || sizes[2] != "shrink") {
5649                   MESSAGE("Invalid order of data in Sizes, must be: "
5650                           "line:int:shrink:float");
5651                 }
5652                 else {
5653                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5654                   aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5655                 }
5656               }
5657               else if (sizes.count() == 6) { // just to support old format
5658                 if (sizes[0] != "line" || sizes[2]  != "node" || sizes[4] != "shrink") {
5659                   MESSAGE("Invalid order of data in Sizes, must be: "
5660                           "line:int:node:int:shrink:float");
5661                 }
5662                 else {
5663                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5664                   //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5665                   aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5666                 }
5667               }
5668             }
5669             // Point marker
5670             else if (paramNameStr == "PointMarker") {
5671               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5672               if( data.count() >= 2 ) {
5673                 bool ok = false;
5674                 int aParam1 = data[1].toInt( &ok );
5675                 if( ok ) {
5676                   if( data[0] == "std" && data.count() == 3 ) {
5677                     int aParam2 = data[2].toInt( &ok );
5678                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5679                   }
5680                   else if( data[0] == "custom" ) {
5681                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5682                     if( markerIt != aMarkerMap.end() ) {
5683                       VTK::MarkerData aMarkerData = markerIt->second;
5684                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5685                     }
5686                   }
5687                 }
5688               }
5689             }
5690             // Opacity
5691             else if (paramNameStr == "Opacity") {
5692               aSmeshActor->SetOpacity(val.toFloat());
5693             }
5694             // Clipping
5695             else if (paramNameStr.startsWith("ClippingPlane")) {
5696               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5697               // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5698               // new format - val looks like "Off" or "0" (plane id)
5699               // (note: in new format "Off" value is used only for consistency,
5700               //  so it is processed together with values in old format)
5701               bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5702               if( anIsOldFormat ) {
5703                 if (paramNameStr == "ClippingPlane1" || val == "Off")
5704                   aSmeshActor->RemoveAllClippingPlanes();
5705                 if (val != "Off") {
5706                   SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5707                   double aDistance = vals[1].toFloat();
5708                   vtkFloatingPointType anAngle[2];
5709                   anAngle[0] = vals[2].toFloat();
5710                   anAngle[1] = vals[3].toFloat();
5711
5712                   QList<SUIT_ViewManager*> lst;
5713                   getApp()->viewManagers(viewerTypStr, lst);
5714                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5715                   if (viewIndex >= 0 && viewIndex < lst.count()) {
5716                     SUIT_ViewManager* vman = lst.at(viewIndex);
5717                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5718
5719                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5720
5721                     SMESH::TActorList anActorList;
5722                     anActorList.push_back( aSmeshActor );
5723                     SMESH::OrientedPlane* aPlane =
5724                       SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5725                     if( aPlane ) {
5726                       SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5727                       aClippingPlaneInfo.Plane = aPlane;
5728                       aClippingPlaneInfo.ActorList = anActorList;
5729                       aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5730                     }
5731                   }
5732                 }
5733               }
5734               else {
5735                 bool ok = false;
5736                 int aPlaneId = val.toInt( &ok );
5737                 if( ok && aPlaneId >= 0 ) {
5738                   bool anIsDefinedPlane = false;
5739                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5740                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5741                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5742                     TPlaneInfo& aPlaneInfo = *anIter;
5743                     if( aPlaneInfo.PlaneId == aPlaneId ) {
5744                       aPlaneInfo.ActorList.push_back( aSmeshActor );
5745                       anIsDefinedPlane = true;
5746                       break;
5747                     }
5748                   }
5749                   if( !anIsDefinedPlane ) {
5750                     TPlaneInfo aPlaneInfo;
5751                     aPlaneInfo.PlaneId = aPlaneId;
5752                     aPlaneInfo.ActorList.push_back( aSmeshActor );
5753                     aPlaneInfo.ViewManager = vman;
5754
5755                     // to make the list sorted by plane id
5756                     anIter = aPlaneInfoList.begin();
5757                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5758                       const TPlaneInfo& aPlaneInfoRef = *anIter;
5759                       if( aPlaneInfoRef.PlaneId > aPlaneId )
5760                         break;
5761                     }
5762                     aPlaneInfoList.insert( anIter, aPlaneInfo );
5763                   }
5764                 }
5765               }
5766             }
5767           } // if (aSmeshActor)
5768         } // other parameters than Visibility
5769       }
5770     } // for names/parameters iterator
5771   } // for entries iterator
5772
5773   // take into account planes with empty list of actors referred to them
5774   QList<SUIT_ViewManager*> aVMList;
5775   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5776
5777   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5778   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5779     int aViewId = aPlaneDataIter->first;
5780     if( aViewId >= 0 && aViewId < aVMList.count() ) {
5781       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5782
5783       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5784
5785       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5786       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5787       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5788         const TPlaneData& aPlaneData = *anIter2;
5789         int aPlaneId = aPlaneData.Id;
5790
5791         bool anIsFound = false;
5792         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5793         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5794           const TPlaneInfo& aPlaneInfo = *anIter3;
5795           if( aPlaneInfo.PlaneId == aPlaneId ) {
5796             anIsFound = true;
5797             break;
5798           }
5799         }
5800
5801         if( !anIsFound ) {
5802           TPlaneInfo aPlaneInfo; // ActorList field is empty
5803           aPlaneInfo.PlaneId = aPlaneId;
5804           aPlaneInfo.ViewManager = aViewManager;
5805
5806           // to make the list sorted by plane id
5807           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5808           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5809             const TPlaneInfo& aPlaneInfoRef = *anIter4;
5810             if( aPlaneInfoRef.PlaneId > aPlaneId )
5811               break;
5812           }
5813           aPlaneInfoList.insert( anIter4, aPlaneInfo );
5814         }
5815       }
5816     }
5817   }
5818
5819   // add clipping planes to actors according to the restored parameters
5820   // and update the clipping plane map
5821   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5822   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5823     int aViewId = anIter1->first;
5824     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5825
5826     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5827     if( anIter2 == aPlaneDataMap.end() )
5828       continue;
5829     const TPlaneDataList& aPlaneDataList = anIter2->second;
5830
5831     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5832     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5833       const TPlaneInfo& aPlaneInfo = *anIter3;
5834       int aPlaneId = aPlaneInfo.PlaneId;
5835       const TActorList& anActorList = aPlaneInfo.ActorList;
5836       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5837       if( !aViewManager )
5838         continue;
5839
5840       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5841       if( !aViewWindow )
5842         continue;
5843
5844       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5845
5846       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5847       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5848         const TPlaneData& aPlaneData = *anIter4;
5849         if( aPlaneData.Id == aPlaneId ) {
5850           SMESH::OrientedPlane* aPlane =
5851             SMESHGUI_ClippingDlg::AddPlane( anActorList,
5852                                             aViewWindow,
5853                                             (SMESH::Orientation)aPlaneData.Orientation,
5854                                             aPlaneData.Distance,
5855                                             aPlaneData.Angle );
5856           if( aPlane ) {
5857             SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5858             aClippingPlaneInfo.Plane = aPlane;
5859             aClippingPlaneInfo.ActorList = anActorList;
5860             aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5861           }
5862           break;
5863         }
5864       }
5865     }
5866   }
5867
5868   // update all VTK views
5869   QList<SUIT_ViewManager*> lst;
5870   getApp()->viewManagers(lst);
5871   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5872     SUIT_ViewModel* vmodel = (*it)->getViewModel();
5873     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5874       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5875       vtkView->getRenderer()->ResetCameraClippingRange();
5876       vtkView->Repaint();
5877     }
5878   }
5879 }
5880
5881 /*!
5882   \brief Adds preferences for dfont of VTK viewer
5883   \param label label
5884   \param pIf group identifier
5885   \param param parameter
5886   \return identifier of preferences
5887 */
5888 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5889 {
5890   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5891
5892   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5893
5894   QStringList fam;
5895   fam.append( tr( "SMESH_FONT_ARIAL" ) );
5896   fam.append( tr( "SMESH_FONT_COURIER" ) );
5897   fam.append( tr( "SMESH_FONT_TIMES" ) );
5898
5899   setPreferenceProperty( tfont, "fonts", fam );
5900
5901   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5902   setPreferenceProperty( tfont, "features", f );
5903
5904   return tfont;
5905 }
5906
5907 /*!
5908   \brief Actions after hypothesis edition
5909   Updates object browser after hypothesis edition
5910 */
5911 void SMESHGUI::onHypothesisEdit( int result )
5912 {
5913   if( result == 1 )
5914     SMESHGUI::Modified();
5915   updateObjBrowser( true );
5916 }
5917
5918
5919 /*!
5920   \brief Signal handler closing(SUIT_ViewWindow*) of a view
5921   \param pview view being closed
5922 */
5923 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5924 #ifndef DISABLE_PLOT2DVIEWER
5925   //Crear all Plot2d Viewers if need.
5926   SMESH::ClearPlot2Viewers(pview);
5927 #endif
5928 }
5929
5930 /*!
5931   \brief Connects or disconnects signals about activating and cloning view on the module slots
5932   \param pview view which is connected/disconnected
5933 */
5934 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
5935   if(!pview)
5936     return;
5937
5938   SUIT_ViewManager* viewMgr = pview->getViewManager();
5939   if ( viewMgr ) {
5940     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5941                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5942
5943     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5944              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5945   }
5946 }
5947
5948 /*!
5949   \brief Return \c true if object can be renamed
5950 */
5951 bool SMESHGUI::renameAllowed( const QString& entry) const {
5952   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5953   if( !anApp )
5954     return false;
5955
5956   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5957   if( !aStudy )
5958     return false;
5959
5960   bool appRes = SalomeApp_Module::renameAllowed(entry);
5961   if( !appRes )
5962     return false;
5963
5964   // check type to prevent renaming of inappropriate objects
5965   int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
5966   if (aType == MESH || aType == GROUP ||
5967       aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5968       aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5969       aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5970       aType == HYPOTHESIS || aType == ALGORITHM)
5971     return true;
5972
5973   return false;
5974 }
5975
5976 /*!
5977   Rename object by entry.
5978   \param entry entry of the object
5979   \param name new name of the object
5980   \brief Return \c true if rename operation finished successfully, \c false otherwise.
5981 */
5982 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
5983
5984   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5985   if( !anApp )
5986     return false;
5987
5988   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5989   if( !aStudy )
5990     return false;
5991
5992   bool appRes = SalomeApp_Module::renameObject(entry,name);
5993   if( !appRes )
5994     return false;
5995
5996   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
5997   _PTR(GenericAttribute) anAttr;
5998   _PTR(AttributeName) aName;
5999   if ( obj ) {
6000     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6001       aName = anAttr;
6002       // check type to prevent renaming of inappropriate objects
6003       int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
6004       if (aType == MESH || aType == GROUP ||
6005           aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6006           aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6007           aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6008           aType == HYPOTHESIS || aType == ALGORITHM) {
6009         if ( !name.isEmpty() ) {
6010           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6011
6012           // update name of group object and its actor
6013           Handle(SALOME_InteractiveObject) IObject =
6014             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6015
6016           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6017           if( !aGroupObject->_is_nil() ) {
6018             aGroupObject->SetName( qPrintable(name) );
6019             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6020               anActor->setName( qPrintable(name) );
6021           }
6022           return true;
6023         }
6024       }
6025     }
6026   }
6027   return false;
6028 }