src/SMESHGUI/SMESHGUI.cxx

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