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