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 //To disable automatic genericobj management, the following line should be commented.
 169 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
 170 #define WITHGENERICOBJ
 171
 172 //namespace{
 173   // Declarations
 174   //=============================================================
 175   void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
 176                             int theCommandID);
 177
 178   void ExportMeshToFile(int theCommandID);
 179
 180   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
 181
 182   void SetDisplayEntity(int theCommandID);
 183
 184   void Control( int theCommandID );
 185
 186
 187   // Definitions
 188   //=============================================================
 189   void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
 190                              int theCommandID )
 191   {
 192     QStringList filter;
 193     std::string myExtension;
 194
 195     if ( theCommandID == 113 ) {
 196       filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
 197       filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
 198     }
 199     else if ( theCommandID == 112 ) {
 200       filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
 201     }
 202     else if ( theCommandID == 111 ) {
 203       filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
 204     }
 205     else if ( theCommandID == 115 ) {
 206       filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
 207     }
 208     else if ( theCommandID == 116 ) {
 209       filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 210     }
 211     else if ( theCommandID == 117 ) {
 212       filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
 213       filter.append( QObject::tr( "All files (*)" ) );
 214     }
 215     else if ( theCommandID == 118 ) {
 216       filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"  );
 217       filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
 218     }
 219
 220     QString anInitialPath = "";
 221     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 222       anInitialPath = QDir::currentPath();
 223
 224     QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
 225                                                             anInitialPath,
 226                                                             filter,
 227                                                             QObject::tr( "SMESH_IMPORT_MESH" ) );
 228     if ( filenames.count() > 0 ) {
 229       SUIT_OverrideCursor wc;
 230       _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
 231
 232       QStringList errors;
 233       QStringList anEntryList;
 234       bool isEmpty = false;
 235       for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
 236         QString filename = *it;
 237         SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
 238         try {
 239           switch ( theCommandID ) {
 240           case 111:
 241             {
 242               // DAT format (currently unsupported)
 243               errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 244                              arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
 245               break;
 246             }
 247           case 112:
 248             {
 249               // UNV format
 250               aMeshes->length( 1 );
 251               aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
 252               if ( aMeshes[0]->_is_nil() )
 253                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 254                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 255               break;
 256             }
 257           case 113:
 258             {
 259               // MED format
 260               SMESH::DriverMED_ReadStatus res;
 261               aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
 262               if ( res != SMESH::DRS_OK ) {
 263                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 264                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 265               }
 266               break;
 267             }
 268           case 115:
 269             {
 270               // STL format
 271               aMeshes->length( 1 );
 272               aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
 273               if ( aMeshes[0]->_is_nil() ) {
 274                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 275                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 276               }
 277               break;
 278             }
 279           case 116:
 280             {
 281               // CGNS format
 282               SMESH::DriverMED_ReadStatus res;
 283               aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
 284               if ( res != SMESH::DRS_OK ) {
 285                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 286                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 287               }
 288               break;
 289             }
 290           case 117:
 291             {
 292               // SAUV format
 293               SMESH::DriverMED_ReadStatus res;
 294               aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
 295               if ( res != SMESH::DRS_OK ) {
 296                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 297                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 298               }
 299               break;
 300             }
 301           case 118:
 302             {
 303               // GMF format
 304               SMESH::ComputeError_var res;
 305               aMeshes->length( 1 );
 306               aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(), res.out() );
 307               if ( res->code != SMESH::DRS_OK ) {
 308                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 309                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
 310                 if ( strlen( res->comment.in() ) > 0 ) {
 311                   errors.back() += ": ";
 312                   errors.back() += res->comment.in();
 313                 }
 314               }
 315               break;
 316             }
 317           }
 318         }
 319         catch ( const SALOME::SALOME_Exception& S_ex ) {
 320           errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 321                          arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 322         }
 323
 324         for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
 325           _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
 326           if ( aMeshSO ) {
 327             _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
 328             _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
 329             aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
 330             if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
 331               SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
 332
 333             anEntryList.append( aMeshSO->GetID().c_str() );
 334
 335 #ifdef WITHGENERICOBJ
 336             // obj has been published in study. Its refcount has been incremented.
 337             // It is safe to decrement its refcount
 338             // so that it will be destroyed when the entry in study will be removed
 339             aMeshes[i]->UnRegister();
 340 #endif
 341           }
 342           else {
 343             isEmpty = true;
 344           }
 345         }
 346       }
 347
 348       // update Object browser
 349       SMESHGUI::GetSMESHGUI()->updateObjBrowser();
 350
 351       // browse to the published meshes
 352       if( LightApp_Application* anApp =
 353           dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
 354         anApp->browseObjects( anEntryList );
 355
 356       // show Error message box if there were errors
 357       if ( errors.count() > 0 ) {
 358         SUIT_MessageBox::critical( SMESHGUI::desktop(),
 359                                    QObject::tr( "SMESH_ERROR" ),
 360                                    QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
 361       }
 362
 363       // show warning message box, if some imported mesh is empty
 364       if ( isEmpty ) {
 365           SUIT_MessageBox::warning( SMESHGUI::desktop(),
 366                                     QObject::tr( "SMESH_WRN_WARNING" ),
 367                                     QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
 368       }
 369     }
 370   }
 371
 372   //================================================================================
 373   /*!
 374    * \brief Export selected meshes or groups into a file
 375    */
 376   //================================================================================
 377
 378   void ExportMeshToFile( int theCommandID )
 379   {
 380     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 381     SALOME_ListIO selected;
 382     if( aSel )
 383       aSel->selectedObjects( selected );
 384
 385     const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
 386     const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
 387     const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
 388     const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
 389     const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
 390     const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
 391     const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
 392
 393     // actually, the following condition can't be met (added for insurance)
 394     if( selected.Extent() == 0 ||
 395         ( selected.Extent() > 1 && !isMED && !isSTL ))
 396       return;
 397
 398     // get mesh object from selection and check duplication of their names
 399     bool hasDuplicatedMeshNames = false;
 400     QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
 401     QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
 402     SALOME_ListIteratorOfListIO It( selected );
 403     for( ; It.More(); It.Next() )
 404     {
 405       Handle(SALOME_InteractiveObject) anIObject = It.Value();
 406       SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
 407       if ( aMeshItem->_is_nil() ) {
 408         SUIT_MessageBox::warning( SMESHGUI::desktop(),
 409                                   QObject::tr( "SMESH_WRN_WARNING" ),
 410                                   QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
 411         return;
 412       }
 413
 414       QString aMeshName = anIObject->getName();
 415
 416       // check for name duplications
 417       if ( !hasDuplicatedMeshNames )
 418         for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 419           if( aMeshName == (*aMeshIter).second ) {
 420             hasDuplicatedMeshNames = true;
 421             break;
 422           }
 423         }
 424
 425       aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
 426     }
 427
 428     if( hasDuplicatedMeshNames && isMED ) {
 429       int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 430                                           QObject::tr("SMESH_WRN_WARNING"),
 431                                           QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
 432                                           QObject::tr("SMESH_BUT_YES"),
 433                                           QObject::tr("SMESH_BUT_NO"), 0, 1);
 434       if (aRet != 0)
 435         return;
 436     }
 437
 438     aMeshIter = aMeshList.begin();
 439     SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 440     SMESH::SMESH_Mesh_var            aMesh = aMeshOrGroup->GetMesh();
 441     QString                      aMeshName = (*aMeshIter).second;
 442
 443     if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
 444     {
 445       // check for equal group names within each mesh
 446       for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 447         SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 448         if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
 449           int aRet = SUIT_MessageBox::warning
 450             (SMESHGUI::desktop(),
 451              QObject::tr("SMESH_WRN_WARNING"),
 452              QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
 453              QObject::tr("SMESH_BUT_YES"),
 454              QObject::tr("SMESH_BUT_NO"), 0, 1);
 455           if (aRet != 0)
 456             return;
 457         }
 458       }
 459     }
 460
 461     // Warn the user about presence of not supported elements
 462     QString format;
 463     std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
 464     if ( isDAT )
 465     {
 466       format = "DAT";
 467       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
 468       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
 469       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 470       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 471       notSupportedElemTypes.push_back( SMESH::Entity_Tetra );
 472       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Tetra );
 473       notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
 474       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
 475       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
 476       notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
 477       notSupportedElemTypes.push_back( SMESH::Entity_Penta );
 478       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
 479       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 480       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 481       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 482       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 483     }
 484     else if ( isUNV )
 485     {
 486       format = "UNV";
 487       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 488       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 489       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 490       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
 491       notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
 492       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 493       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 494       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 495     }
 496     else if ( isSTL )
 497     {
 498       format = "STL";
 499       notSupportedElemTypes.push_back( SMESH::Entity_Edge );
 500       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
 501       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 502       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 503     }
 504     else if ( isCGNS )
 505     {
 506       format = "CGNS";
 507       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 508     }
 509     else if ( isSAUV )
 510     {
 511       format = "SAUV";
 512       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 513       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
 514       notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
 515       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 516       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 517       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 518     }
 519     else if ( isGMF )
 520     {
 521       format = "GMF";
 522       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 523       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
 524       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 525       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 526       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
 527       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
 528       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
 529       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 530       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 531       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
 532       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 533     }
 534     if ( ! notSupportedElemTypes.empty() )
 535     {
 536       SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
 537       for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
 538         if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
 539           presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
 540     }
 541     if ( !presentNotSupported.empty() )
 542     {
 543       QString typeNames;
 544       const char* typeMsg[SMESH::Entity_Last] = { "SMESH_NODES",
 545         "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES","SMESH_TRIANGLES",
 546         "SMESH_QUADRATIC_TRIANGLES","SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES",
 547         "SMESH_BIQUADRATIC_QUADRANGLES","SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
 548         "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
 549         "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
 550         "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
 551         "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
 552       };
 553       QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
 554       for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
 555         typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
 556         if ( iType != presentNotSupported.size() - 1 )
 557           typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
 558       }
 559       int aRet = SUIT_MessageBox::warning
 560         (SMESHGUI::desktop(),
 561          QObject::tr("SMESH_WRN_WARNING"),
 562          QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
 563          QObject::tr("SMESH_BUT_YES"),
 564          QObject::tr("SMESH_BUT_NO"), 0, 1);
 565       if (aRet != 0)
 566         return;
 567     }
 568
 569     // Get parameters of export operation
 570
 571     QString            aFilename;
 572     SMESH::MED_VERSION aFormat;
 573     // Init the parameters with the default values
 574     bool aIsASCII_STL   = true;
 575     bool toCreateGroups = false;
 576     SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 577     if ( resMgr )
 578       toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
 579     bool toOverwrite = true;
 580
 581     QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
 582     QString anInitialPath = "";
 583     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 584       anInitialPath = QDir::currentPath();
 585
 586     // Get a file name to write in and additional otions
 587     if ( isUNV || isDAT || isGMF ) // Export w/o options
 588     {
 589       if ( isUNV )
 590         aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
 591       else if ( isDAT )
 592         aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
 593       else if ( isGMF )
 594         aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
 595           ";;" +  QObject::tr( "GMF_BINARY_FILES_FILTER" )  + " (*.meshb)";
 596       if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
 597       aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
 598                                             anInitialPath + QString("/") + aMeshName,
 599                                             aFilter, aTitle, false);
 600     }
 601     else if ( isCGNS )// Export to CGNS
 602     {
 603       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 604       fd->setWindowTitle( aTitle );
 605       fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 606       if ( !anInitialPath.isEmpty() )
 607         fd->setDirectory( anInitialPath );
 608       fd->selectFile(aMeshName);
 609       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 610       fd->setValidator( fv );
 611
 612       if ( fd->exec() )
 613         aFilename = fd->selectedFile();
 614       toOverwrite = fv->isOverwrite();
 615
 616       delete fd;
 617     }
 618     else if ( isSTL ) // Export to STL
 619     {
 620       QMap<QString, int> aFilterMap;
 621       aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
 622       aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" )   + " (*.stl)", 0 );
 623
 624       QStringList filters;
 625       QMap<QString, int>::const_iterator it = aFilterMap.begin();
 626       for ( ; it != aFilterMap.end(); ++it )
 627         filters.push_back( it.key() );
 628
 629       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 630       fd->setWindowTitle( aTitle );
 631       fd->setNameFilters( filters );
 632       fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
 633       if ( !anInitialPath.isEmpty() )
 634         fd->setDirectory( anInitialPath );
 635       fd->selectFile(aMeshName);
 636       bool is_ok = false;
 637       while (!is_ok) {
 638         if ( fd->exec() )
 639           aFilename = fd->selectedFile();
 640         aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
 641         is_ok = true;
 642       }
 643       delete fd;
 644     }
 645     else if ( isMED || isSAUV ) // Export to MED or SAUV
 646     {
 647       QMap<QString, SMESH::MED_VERSION> aFilterMap;
 648       //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
 649       if ( isMED ) {
 650         QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
 651         //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
 652         aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
 653       }
 654       else { // isSAUV
 655         aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
 656         aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
 657         aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
 658       }
 659
 660       QStringList filters;
 661       QString aDefaultFilter;
 662       QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
 663       for ( ; it != aFilterMap.end(); ++it ) {
 664         filters.push_back( it.key() );
 665         if (it.value() == SMESH::MED_V2_2)
 666           aDefaultFilter = it.key();
 667       }
 668
 669       SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
 670         ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
 671       fd->setWindowTitle( aTitle );
 672       fd->setNameFilters( filters );
 673       fd->selectNameFilter(aDefaultFilter);
 674       fd->SetChecked(toCreateGroups);
 675       if ( !anInitialPath.isEmpty() )
 676         fd->setDirectory( anInitialPath );
 677       fd->selectFile(aMeshName);
 678
 679       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 680       fd->setValidator( fv );
 681
 682       bool is_ok = false;
 683       while (!is_ok) {
 684         if ( fd->exec() )
 685           aFilename = fd->selectedFile();
 686         else {
 687           aFilename = QString::null;
 688           break;
 689         }
 690         aFormat = aFilterMap[fd->selectedNameFilter()];
 691         toOverwrite = fv->isOverwrite();
 692         is_ok = true;
 693         if ( !aFilename.isEmpty() ) {
 694           // med-2.1 does not support poly elements
 695           if ( aFormat==SMESH::MED_V2_1 )
 696             for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 697               SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
 698               SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
 699               if ( nbElems[ SMESH::Entity_Polygon   ] + nbElems[ SMESH::Entity_Quad_Polygon   ] +
 700                    nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
 701               {
 702                 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 703                                                     QObject::tr("SMESH_WRN_WARNING"),
 704                                                     QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
 705                                                     QObject::tr("SMESH_BUT_YES"),
 706                                                     QObject::tr("SMESH_BUT_NO"), 0, 1);
 707                 if (aRet != 0) {
 708                   is_ok = false;
 709                   break;
 710                 }
 711               }
 712             }
 713           if( !toOverwrite ) {
 714             // can't append to an existing using other format
 715             SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
 716             bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
 717             if( !isVersionOk || aVersion != aFormat ) {
 718               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 719                                                   QObject::tr("SMESH_WRN_WARNING"),
 720                                                   QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
 721                                                   QObject::tr("SMESH_BUT_YES"),
 722                                                   QObject::tr("SMESH_BUT_NO"), 0, 1);
 723               if (aRet == 0)
 724                 toOverwrite = true;
 725               else
 726                 is_ok = false;
 727             }
 728
 729             QStringList aMeshNamesCollisionList;
 730             SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
 731             for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
 732               QString anExistingMeshName( aMeshNames[ i ] );
 733               for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 734                 QString anExportMeshName = (*aMeshIter).second;
 735                 if( anExportMeshName == anExistingMeshName ) {
 736                   aMeshNamesCollisionList.append( anExportMeshName );
 737                   break;
 738                 }
 739               }
 740             }
 741             if( !aMeshNamesCollisionList.isEmpty() ) {
 742               QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
 743               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 744                                                   QObject::tr("SMESH_WRN_WARNING"),
 745                                                   QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
 746                                                   QObject::tr("SMESH_BUT_YES"),
 747                                                   QObject::tr("SMESH_BUT_NO"),
 748                                                   QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
 749               if (aRet == 0)
 750                 toOverwrite = true;
 751               else if (aRet == 2)
 752                 is_ok = false;
 753             }
 754           }
 755         }
 756       }
 757       toCreateGroups = fd->IsChecked();
 758       delete fd;
 759     }
 760     else
 761     {
 762       return;
 763     }
 764
 765     // Perform export
 766
 767     if ( !aFilename.isEmpty() ) {
 768       // Check whether the file already exists and delete it if yes
 769       QFile aFile( aFilename );
 770       if ( aFile.exists() && toOverwrite )
 771         aFile.remove();
 772       SUIT_OverrideCursor wc;
 773
 774       try {
 775         // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
 776 //         bool Renumber = false;
 777 //         // PAL 14172  : Check of we have to renumber or not from the preferences before export
 778 //         if (resMgr)
 779 //           Renumber= resMgr->booleanValue("renumbering");
 780 //         if (Renumber){
 781 //           SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
 782 //           aMeshEditor->RenumberNodes();
 783 //           aMeshEditor->RenumberElements();
 784 //           if ( SMESHGUI::automaticUpdate() )
 785 //             SMESH::UpdateView();
 786 //         }
 787         if ( isMED )
 788         {
 789           aMeshIter = aMeshList.begin();
 790           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 791           {
 792             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 793             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 794             if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
 795               aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
 796                                        aFormat, toOverwrite && aMeshIndex == 0 );
 797             else
 798               aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
 799                                           aFormat, toOverwrite && aMeshIndex == 0 );
 800           }
 801         }
 802         else if ( isSAUV )
 803         {
 804           for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
 805           {
 806             SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 807             if( !aMeshItem->_is_nil() )
 808               aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
 809           }
 810         }
 811         else if ( isDAT )
 812         {
 813           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 814             aMesh->ExportDAT( aFilename.toLatin1().data() );
 815           else
 816             aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
 817         }
 818         else if ( isUNV )
 819         {
 820           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 821             aMesh->ExportUNV( aFilename.toLatin1().data() );
 822           else
 823             aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
 824         }
 825         else if ( isSTL )
 826         {
 827           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 828             aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
 829           else
 830             aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
 831         }
 832         else if ( isCGNS )
 833         {
 834           aMeshIter = aMeshList.begin();
 835           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 836           {
 837             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 838             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 839             aMeshItem->ExportCGNS( aMeshOrGroup,
 840                                    aFilename.toLatin1().data(),
 841                                    toOverwrite && aMeshIndex == 0 );
 842           }
 843         }
 844         else if ( isGMF )
 845         {
 846           aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data() );
 847         }
 848       }
 849       catch (const SALOME::SALOME_Exception& S_ex){
 850         wc.suspend();
 851         SUIT_MessageBox::warning(SMESHGUI::desktop(),
 852                                  QObject::tr("SMESH_WRN_WARNING"),
 853                                  QObject::tr("SMESH_EXPORT_FAILED"));
 854         wc.resume();
 855       }
 856     }
 857   }
 858
 859   inline void InverseEntityMode(unsigned int& theOutputMode,
 860                                 unsigned int theMode)
 861   {
 862     bool anIsNotPresent = ~theOutputMode & theMode;
 863     if(anIsNotPresent)
 864       theOutputMode |= theMode;
 865     else
 866       theOutputMode &= ~theMode;
 867   }
 868
 869   void SetDisplayEntity(int theCommandID){
 870     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 871     SALOME_ListIO selected;
 872     if( aSel )
 873       aSel->selectedObjects( selected );
 874
 875     if(selected.Extent() >= 1){
 876       SALOME_ListIteratorOfListIO It( selected );
 877       for( ; It.More(); It.Next()){
 878         Handle(SALOME_InteractiveObject) IObject = It.Value();
 879         if(IObject->hasEntry()){
 880           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
 881             unsigned int aMode = anActor->GetEntityMode();
 882             switch(theCommandID){
 883             case 222:
 884               InverseEntityMode(aMode,SMESH_Actor::eBallElem);
 885               break;
 886             case 216:
 887               InverseEntityMode(aMode,SMESH_Actor::e0DElements);
 888               break;
 889             case 217:
 890               InverseEntityMode(aMode,SMESH_Actor::eEdges);
 891               break;
 892             case 218:
 893               InverseEntityMode(aMode,SMESH_Actor::eFaces);
 894               break;
 895             case 219:
 896               InverseEntityMode(aMode,SMESH_Actor::eVolumes);
 897               break;
 898             case 220:
 899               aMode = SMESH_Actor::eAllEntity;
 900               break;
 901             }
 902             if(aMode)
 903               anActor->SetEntityMode(aMode);
 904           }
 905         }
 906       }
 907     }
 908   }
 909
 910   void AutoColor(){
 911     SALOME_ListIO selected;
 912     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 913     if( !app )
 914       return;
 915
 916     LightApp_SelectionMgr* aSel = app->selectionMgr();
 917     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
 918     if( !aSel || !appStudy )
 919       return;
 920
 921     aSel->selectedObjects( selected );
 922     if( selected.IsEmpty() )
 923       return;
 924
 925     Handle(SALOME_InteractiveObject) anIObject = selected.First();
 926
 927     _PTR(Study) aStudy = appStudy->studyDS();
 928     _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
 929     SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
 930     if( aMainObject->_is_nil() )
 931       return;
 932
 933     aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
 934
 935     SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
 936     for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
 937     {
 938       SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
 939       SALOMEDS::Color aColor = aGroupObject->GetColor();
 940       _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
 941       if (aGroupSObject) {
 942         QColor c;
 943         int delta;
 944         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
 945           switch ( aGroupObject->GetType ()) {
 946           case SMESH::NODE:
 947             anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
 948           case SMESH::EDGE:
 949             anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
 950           case SMESH::ELEM0D:
 951             anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
 952           case SMESH::BALL:
 953             anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
 954           case SMESH::VOLUME:
 955             SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
 956             anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
 957           case SMESH::FACE:
 958           default:
 959             SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
 960             anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
 961           }
 962         }
 963       }
 964     }
 965
 966     SMESH::RepaintCurrentView();
 967   }
 968
 969   QString functorToString( SMESH::Controls::FunctorPtr f )
 970   {
 971     QString type = QObject::tr( "UNKNOWN_CONTROL" );
 972     if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
 973       type = QObject::tr( "VOLUME_3D_ELEMENTS" );
 974     else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
 975       type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
 976     else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
 977       type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
 978     else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
 979       type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
 980     else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
 981       type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
 982     else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
 983       type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
 984     else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
 985       type = QObject::tr( "WARP_ELEMENTS" );
 986     else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
 987       type = QObject::tr( "TAPER_ELEMENTS" );
 988     else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
 989       type = QObject::tr( "SKEW_ELEMENTS" );
 990     else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
 991       type = QObject::tr( "AREA_ELEMENTS" );
 992     else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
 993       type = QObject::tr( "LENGTH_EDGES" );
 994     else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
 995       type = QObject::tr( "LENGTH2D_EDGES" );
 996     else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
 997       type = QObject::tr( "MULTI_BORDERS" );
 998     else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
 999       type = QObject::tr( "MULTI2D_BORDERS" );
1000     else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1001       type = QObject::tr( "FREE_NODES" );
1002     else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1003       type = QObject::tr( "FREE_EDGES" );
1004     else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1005       type = QObject::tr( "FREE_BORDERS" );
1006     else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1007       type = QObject::tr( "FREE_FACES" );
1008     else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1009       type = QObject::tr( "BARE_BORDER_VOLUME" );
1010     else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1011       type = QObject::tr( "BARE_BORDER_FACE" );
1012     else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1013       type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1014     else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1015       type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1016     else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1017       type = QObject::tr( "EQUAL_NODE" );
1018     else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1019       type = QObject::tr( "EQUAL_EDGE" );
1020     else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1021       type = QObject::tr( "EQUAL_FACE" );
1022     else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1023       type = QObject::tr( "EQUAL_VOLUME" );
1024     return type;
1025   }
1026
1027   void SaveDistribution()
1028   {
1029     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1030     SALOME_ListIO selected;
1031     if ( aSel )
1032       aSel->selectedObjects( selected );
1033
1034     if ( selected.Extent() == 1 ) {
1035       Handle(SALOME_InteractiveObject) anIO = selected.First();
1036       if ( anIO->hasEntry() ) {
1037         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1038         if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1039           SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1040           SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1041           if ( aScalarBarActor && aFunctor ) {
1042             SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1043             if ( aNumFun ) {
1044               std::vector<int> elements;
1045               SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1046               if ( mesh->_is_nil() ) {
1047                 SMESH::SMESH_IDSource_var idSource =
1048                   SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1049                 if ( !idSource->_is_nil() )
1050                 {
1051                   SMESH::long_array_var ids = idSource->GetIDs();
1052                   elements.resize( ids->length() );
1053                   for ( unsigned i = 0; i < elements.size(); ++i )
1054                     elements[i] = ids[i];
1055                 }
1056               }
1057               int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1058               vtkLookupTable* lookupTable =
1059                 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1060               double * minmax = lookupTable->GetRange();
1061               std::vector<int>    nbEvents;
1062               std::vector<double> funValues;
1063               aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
1064               QString anInitialPath = "";
1065               if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1066                 anInitialPath = QDir::currentPath();
1067               QString aMeshName = anIO->getName();
1068               QStringList filter;
1069               filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1070               filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1071               QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1072                 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1073               aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1074                                                      aFilename,
1075                                                      filter,
1076                                                      QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1077                                                      false );
1078               if ( !aFilename.isEmpty() ) {
1079                 QFile f( aFilename );
1080                 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1081                   QTextStream out( &f );
1082                   out << "# Mesh: " << aMeshName << endl;
1083                   out << "# Control: " << functorToString( aFunctor ) << endl;
1084                   out << "#" << endl;
1085                   out.setFieldWidth( 10 );
1086                   for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1087                     out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1088                   f.close();
1089                 }
1090               }
1091             }
1092           }
1093         }
1094       }
1095     }
1096   }
1097
1098   void ShowDistribution() {
1099     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1100     SALOME_ListIO selected;
1101     if ( aSel )
1102       aSel->selectedObjects( selected );
1103
1104     if ( selected.Extent() == 1 ) {
1105       Handle(SALOME_InteractiveObject) anIO = selected.First();
1106       if ( anIO->hasEntry() ) {
1107         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1108         if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1109           SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1110           aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1111         }
1112       }
1113     }
1114   }
1115
1116 #ifndef DISABLE_PLOT2DVIEWER
1117  void PlotDistribution() {
1118    SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1119    if( !app )
1120      return;
1121
1122    LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1123    SALOME_ListIO selected;
1124    if ( aSel )
1125      aSel->selectedObjects( selected );
1126
1127    if ( selected.Extent() == 1 ) {
1128      Handle(SALOME_InteractiveObject) anIO = selected.First();
1129      if ( anIO->hasEntry() ) {
1130        //Find Actor by entry before getting Plot2d viewer,
1131        //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1132        SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1133
1134        SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1135
1136        if( !aViewManager )
1137          return;
1138
1139        SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1140        if ( !aView )
1141          return;
1142
1143        Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1144        if ( !aPlot )
1145          return;
1146
1147        if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1148          SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1149          QString functorName = functorToString( anActor->GetFunctor());
1150          QString aHistogramName("%1 : %2");
1151          aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1152          aHistogram->setName(aHistogramName);
1153          aHistogram->setHorTitle(functorName);
1154          aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1155          aPlot->displayObject(aHistogram, true);
1156        }
1157      }
1158    }
1159  }
1160 #endif //DISABLE_PLOT2DVIEWER
1161
1162   void DisableAutoColor(){
1163     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1164     SALOME_ListIO selected;
1165     if( aSel )
1166       aSel->selectedObjects( selected );
1167
1168     if(selected.Extent()){
1169       Handle(SALOME_InteractiveObject) anIObject = selected.First();
1170       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1171       if ( !aMesh->_is_nil() ) {
1172         aMesh->SetAutoColor( false );
1173       }
1174     }
1175   }
1176
1177   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1178   {
1179     SALOME_ListIO selected;
1180     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1181     if( !app )
1182       return;
1183
1184     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1185     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1186     if( !aSel || !appStudy )
1187       return;
1188
1189     if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1190       if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1191         aModule->EmitSignalDeactivateDialog();
1192         if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1193           (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1194       }
1195       return;
1196     }
1197
1198     _PTR(Study) aStudy = appStudy->studyDS();
1199
1200     aSel->selectedObjects( selected );
1201
1202     if(selected.Extent() >= 1){
1203       switch(theCommandID){
1204       case 1133:{
1205         SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1206         (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1207         return;
1208       }
1209       case 1132: {
1210         vtkFloatingPointType color[3];
1211         QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1212         QColor orientationColor, outlineColor, volumeColor;
1213         int deltaF = 0, deltaV = 0;
1214         int elem0dSize   = 1;
1215         int ballSize     = 1;
1216         int edgeWidth    = 1;
1217         int outlineWidth = 1;
1218         vtkFloatingPointType shrinkCoef = 0.0;
1219         vtkFloatingPointType orientationScale = 0.0;
1220         bool orientation3d = false;
1221         VTK::MarkerType markerType = VTK::MT_NONE;
1222         VTK::MarkerScale markerScale = VTK::MS_NONE;
1223         int markerId = 0;
1224         bool hasNodes = false;
1225         int presentEntities = 0;
1226         bool firstTime  = true;
1227
1228         SALOME_ListIteratorOfListIO It( selected );
1229         for ( ; It.More(); It.Next() ) {
1230           Handle(SALOME_InteractiveObject) IObject = It.Value();
1231           if ( !IObject->hasEntry() ) continue;
1232           SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1233           if ( !anActor || !anActor->GetObject() ) continue;
1234
1235           if ( firstTime ) {
1236             // nodes: color, marker
1237             anActor->GetNodeColor( color[0], color[1], color[2] );
1238             nodeColor.setRgbF( color[0], color[1], color[2] );
1239             markerType  = anActor->GetMarkerType();
1240             markerScale = anActor->GetMarkerScale();
1241             markerId    = anActor->GetMarkerTexture();
1242             // edges: color, width
1243             anActor->GetEdgeColor( color[0], color[1], color[2] );
1244             edgeColor.setRgbF( color[0], color[1], color[2] );
1245             edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1246             // faces: front color, back color (delta)
1247             anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1248             faceColor.setRgbF( color[0], color[1], color[2] );
1249             // faces: front color, back color (delta)
1250             anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1251             volumeColor.setRgbF( color[0], color[1], color[2] );
1252             // 0d elements: color, size
1253             anActor->Get0DColor( color[0], color[1], color[2] );
1254             elem0dColor.setRgbF( color[0], color[1], color[2] );
1255             elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1256             // balls: color, size
1257             anActor->GetBallColor( color[0], color[1], color[2] );
1258             ballColor.setRgbF( color[0], color[1], color[2] );
1259             ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1260             // outlines: color
1261             anActor->GetOutlineColor( color[0], color[1], color[2] );
1262             outlineColor.setRgbF( color[0], color[1], color[2] );
1263             outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1264             // orientation vectors: color, scale, 3d flag
1265             anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1266             orientationColor.setRgbF( color[0], color[1], color[2] );
1267             orientationScale = anActor->GetFacesOrientationScale();
1268             orientation3d = anActor->GetFacesOrientation3DVectors();
1269             // shrink factor
1270             shrinkCoef = anActor->GetShrinkFactor();
1271           }
1272
1273           firstTime = false; // we only take properties from first object (for performance reasons)
1274
1275           if ( !hasNodes )
1276             hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1277           if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1278             presentEntities = presentEntities | SMESH_Actor::eEdges;
1279           if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1280             presentEntities = presentEntities | SMESH_Actor::eFaces;
1281           if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1282             presentEntities = presentEntities | SMESH_Actor::eVolumes;
1283           if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1284             presentEntities = presentEntities | SMESH_Actor::e0DElements;
1285           if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1286             presentEntities = presentEntities | SMESH_Actor::eBallElem;
1287
1288           // as we know that all types of elements are present, we can exit the loop
1289           if ( presentEntities == SMESH_Actor::eAllEntity )
1290             break;
1291         }
1292
1293         SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1294         // nodes: color, marker
1295         dlg.setNodeColor( nodeColor );
1296         if( markerType != VTK::MT_USER )
1297           dlg.setNodeMarker( markerType, markerScale );
1298         else
1299           dlg.setNodeCustomMarker( markerId );
1300         // edges: color, line width
1301         dlg.setEdgeColor( edgeColor );
1302         dlg.setEdgeWidth( edgeWidth );
1303         // faces: front color, back color
1304         dlg.setFaceColor( faceColor, deltaF );
1305         // volumes: normal color, reversed color
1306         dlg.setVolumeColor( volumeColor, deltaV );
1307         // outlines: color, line width
1308         dlg.setOutlineColor( outlineColor );
1309         dlg.setOutlineWidth( outlineWidth );
1310         // 0d elements: color, size
1311         dlg.setElem0dColor( elem0dColor );
1312         dlg.setElem0dSize( elem0dSize );
1313         // balls: color, size
1314         dlg.setBallColor( ballColor );
1315         dlg.setBallSize( ballSize );
1316         // orientation: color, scale, 3d flag
1317         dlg.setOrientationColor( orientationColor );
1318         dlg.setOrientationSize( int( orientationScale * 100. ) );
1319         dlg.setOrientation3d( orientation3d );
1320         // shrink: scale factor
1321         dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1322         // hide unused controls
1323         dlg.showControls( presentEntities, hasNodes );
1324
1325         if ( dlg.exec() ) {
1326           nodeColor        = dlg.nodeColor();
1327           markerType       = dlg.nodeMarkerType();
1328           markerScale      = dlg.nodeMarkerScale();
1329           markerId         = dlg.nodeMarkerId();
1330           edgeColor        = dlg.edgeColor();
1331           edgeWidth        = dlg.edgeWidth();
1332           faceColor        = dlg.faceColor();
1333           deltaF           = dlg.faceColorDelta();
1334           volumeColor      = dlg.volumeColor();
1335           deltaV           = dlg.volumeColorDelta();
1336           outlineColor     = dlg.outlineColor();
1337           outlineWidth     = dlg.outlineWidth();
1338           elem0dColor      = dlg.elem0dColor();
1339           elem0dSize       = dlg.elem0dSize();
1340           ballColor        = dlg.ballColor();
1341           ballSize         = dlg.ballSize();
1342           orientationColor = dlg.orientationColor();
1343           orientationScale = dlg.orientationSize() / 100.;
1344           orientation3d    = dlg.orientation3d();
1345           shrinkCoef       = dlg.shrinkCoef() / 100.;
1346
1347           // store point markers map that might be changed by the user
1348           theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1349
1350           // set properties from dialog box to the presentations
1351           SALOME_ListIteratorOfListIO It( selected );
1352           for ( ; It.More(); It.Next() ) {
1353             Handle(SALOME_InteractiveObject) IObject = It.Value();
1354             if ( !IObject->hasEntry() ) continue;
1355             SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1356             if ( !anActor ) continue;
1357
1358             // nodes: color, marker
1359             anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1360             if ( markerType != VTK::MT_USER ) {
1361               anActor->SetMarkerStd( markerType, markerScale );
1362             }
1363             else {
1364               const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1365               VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1366               if ( iter != markerMap.end() )
1367                 anActor->SetMarkerTexture( markerId, iter->second.second );
1368             }
1369             // volumes: normal color, reversed color (delta)
1370             anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1371             // faces: front color, back color (delta)
1372             anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1373             // edges: color, width
1374             anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1375             anActor->SetLineWidth( edgeWidth );
1376             // outlines: color
1377             anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1378             anActor->SetOutlineWidth( outlineWidth );
1379             // 0D elements: color, size
1380             anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1381             anActor->Set0DSize( elem0dSize );
1382             // balls: color, size
1383             anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1384             anActor->SetBallSize( ballSize );
1385             // orientation: color, scale, 3d flag
1386             anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1387             anActor->SetFacesOrientationScale( orientationScale );
1388             anActor->SetFacesOrientation3DVectors( orientation3d );
1389             // shrink factor
1390             anActor->SetShrinkFactor( shrinkCoef );
1391
1392             // for groups, set also proper color
1393             SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1394             if ( !aGroupObject->_is_nil() ) {
1395               SMESH::ElementType anElementType = aGroupObject->GetType();
1396               QColor aColor;
1397               switch( anElementType ) {
1398               case SMESH::NODE:
1399                 aColor = nodeColor; break;
1400               case SMESH::EDGE:
1401                 aColor = edgeColor; break;
1402               case SMESH::FACE:
1403                 aColor = faceColor; break;
1404               case SMESH::VOLUME:
1405                 aColor = volumeColor; break;
1406               case SMESH::ELEM0D:
1407                 aColor = elem0dColor; break;
1408               case SMESH::BALL:
1409                 aColor = ballColor; break;
1410               default: break;
1411               }
1412
1413               if ( aColor.isValid() ) {
1414                 SALOMEDS::Color aGroupColor;
1415                 aGroupColor.R = aColor.redF();
1416                 aGroupColor.G = aColor.greenF();
1417                 aGroupColor.B = aColor.blueF();
1418                 aGroupObject->SetColor( aGroupColor );
1419               }
1420             } // if ( !aGroupObject->_is_nil() )
1421           } // for ( ; It.More(); It.Next() )
1422           SMESH::RepaintCurrentView();
1423         } // if ( dlg.exec() )
1424         return;
1425       } // case 1132:
1426       } // switch(theCommandID)
1427       SALOME_ListIteratorOfListIO It( selected );
1428       for( ; It.More(); It.Next()){
1429         Handle(SALOME_InteractiveObject) IObject = It.Value();
1430         if(IObject->hasEntry()){
1431           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1432             switch(theCommandID){
1433             case 211:
1434               anActor->SetRepresentation(SMESH_Actor::eEdge);
1435               break;
1436             case 212:
1437               anActor->SetRepresentation(SMESH_Actor::eSurface);
1438               break;
1439             case 213:
1440               if(anActor->IsShrunk())
1441                 anActor->UnShrink();
1442               else
1443                 anActor->SetShrink();
1444               break;
1445             case 215:
1446               anActor->SetRepresentation(SMESH_Actor::ePoint);
1447               break;
1448             case 231:
1449               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1450                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1451               break;
1452             case 232:
1453               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1454                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1455               break;
1456             }
1457           }
1458         }
1459       }
1460       SMESH::RepaintCurrentView();
1461     }
1462   }
1463
1464   void Control( int theCommandID )
1465   {
1466     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1467     SALOME_ListIO selected;
1468     if( aSel )
1469       aSel->selectedObjects( selected );
1470
1471     if( !selected.IsEmpty() ){
1472       Handle(SALOME_InteractiveObject) anIO = selected.First();
1473       if(!anIO.IsNull()){
1474         SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1475         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1476           switch ( theCommandID ){
1477           case 6001:
1478             aControl = SMESH_Actor::eLength;
1479             break;
1480           case 6018:
1481             aControl = SMESH_Actor::eLength2D;
1482             break;
1483           case 6002:
1484             aControl = SMESH_Actor::eFreeEdges;
1485             break;
1486           case 6003:
1487             aControl = SMESH_Actor::eFreeBorders;
1488             break;
1489           case 6004:
1490             aControl = SMESH_Actor::eMultiConnection;
1491             break;
1492           case 6005:
1493             aControl = SMESH_Actor::eFreeNodes;
1494             break;
1495           case 6019:
1496             aControl = SMESH_Actor::eMultiConnection2D;
1497             break;
1498           case 6011:
1499             aControl = SMESH_Actor::eArea;
1500             break;
1501           case 6012:
1502             aControl = SMESH_Actor::eTaper;
1503             break;
1504           case 6013:
1505             aControl = SMESH_Actor::eAspectRatio;
1506             break;
1507           case 6017:
1508             aControl = SMESH_Actor::eAspectRatio3D;
1509             break;
1510           case 6014:
1511             aControl = SMESH_Actor::eMinimumAngle;
1512             break;
1513           case 6015:
1514             aControl = SMESH_Actor::eWarping;
1515             break;
1516           case 6016:
1517             aControl = SMESH_Actor::eSkew;
1518             break;
1519           case 6009:
1520             aControl = SMESH_Actor::eVolume3D;
1521             break;
1522           case 6021:
1523             aControl = SMESH_Actor::eFreeFaces;
1524             break;
1525           case 6022:
1526             aControl = SMESH_Actor::eMaxElementLength2D;
1527             break;
1528           case 6023:
1529             aControl = SMESH_Actor::eMaxElementLength3D;
1530             break;
1531           case 6024:
1532             aControl = SMESH_Actor::eBareBorderVolume;
1533             break;
1534           case 6025:
1535             aControl = SMESH_Actor::eBareBorderFace;
1536             break;
1537           case 6026:
1538             aControl = SMESH_Actor::eOverConstrainedVolume;
1539             break;
1540           case 6027:
1541             aControl = SMESH_Actor::eOverConstrainedFace;
1542             break;
1543           case 6028:
1544             aControl = SMESH_Actor::eCoincidentNodes;
1545             break;
1546           case 6029:
1547             aControl = SMESH_Actor::eCoincidentElems1D;
1548             break;
1549           case 6030:
1550             aControl = SMESH_Actor:: eCoincidentElems2D;
1551             break;
1552           case 6031:
1553             aControl = SMESH_Actor::eCoincidentElems3D;
1554             break;
1555           }
1556
1557           anActor->SetControlMode(aControl);
1558           anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1559           SMESH::RepaintCurrentView();
1560 #ifndef DISABLE_PLOT2DVIEWER
1561           if(anActor->GetPlot2Histogram()) {
1562             SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1563             QString functorName = functorToString( anActor->GetFunctor());
1564             QString aHistogramName("%1 : %2");
1565             aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1566             aHistogram->setName(aHistogramName);
1567             aHistogram->setHorTitle(functorName);
1568             SMESH::ProcessIn2DViewers(anActor);
1569           }
1570 #endif
1571         }
1572       }
1573     }
1574   }
1575
1576
1577   bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1578                    MeshObjectType                           theType,
1579                    const QString                            theInTypeName,
1580                    QString &                                theOutTypeName)
1581   {
1582     SMESH_TypeFilter aTypeFilter( theType );
1583     QString entry;
1584     if( !theIO.IsNull() )
1585     {
1586       entry = theIO->getEntry();
1587       LightApp_DataOwner owner( entry );
1588       if ( aTypeFilter.isOk( &owner )) {
1589         theOutTypeName = theInTypeName;
1590         return true;
1591       }
1592     }
1593     return false;
1594   }
1595
1596
1597   QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1598   {
1599     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1600     _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1601     if (aSObj) {
1602       _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1603       CORBA::String_var anID = aSComp->GetID().c_str();
1604       if (!strcmp(anID.in(),theIO->getEntry()))
1605         return "Component";
1606     }
1607
1608     QString aTypeName;
1609     if (
1610         CheckOIType ( theIO, HYPOTHESIS,    "Hypothesis", aTypeName ) ||
1611         CheckOIType ( theIO, ALGORITHM,     "Algorithm",  aTypeName ) ||
1612         CheckOIType ( theIO, MESH,          "Mesh",       aTypeName ) ||
1613         CheckOIType ( theIO, SUBMESH,       "SubMesh",    aTypeName ) ||
1614         CheckOIType ( theIO, GROUP,         "Group",      aTypeName )
1615         )
1616       return aTypeName;
1617
1618     return "NoType";
1619   }
1620
1621
1622   QString CheckHomogeneousSelection()
1623   {
1624     //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1625     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1626     SALOME_ListIO selected;
1627     if( aSel )
1628       aSel->selectedObjects( selected );
1629
1630     QString RefType = CheckTypeObject(selected.First());
1631     SALOME_ListIteratorOfListIO It(selected);
1632     for ( ; It.More(); It.Next())
1633       {
1634         Handle(SALOME_InteractiveObject) IObject = It.Value();
1635         QString Type = CheckTypeObject(IObject);
1636         if (Type.compare(RefType) != 0)
1637           return "Heterogeneous Selection";
1638       }
1639
1640     return RefType;
1641   }
1642
1643
1644   void SMESHGUI::OnEditDelete()
1645   {
1646     // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1647     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1648     SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1649
1650     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1651     _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1652     _PTR(GenericAttribute) anAttr;
1653     _PTR(AttributeIOR) anIOR;
1654
1655     int objectCount = 0;
1656     QString aNameList;
1657     QString aParentComponent = QString::null;
1658     Handle(SALOME_InteractiveObject) anIO;
1659     for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1660     {
1661       anIO = anIt.Value();
1662       QString cur = anIO->getComponentDataType();
1663       _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1664       if (aSO) {
1665         // check if object is reference
1666         _PTR(SObject) aRefSObj;
1667         aNameList.append("\n    - ");
1668         if ( aSO->ReferencedObject( aRefSObj ) ) {
1669           QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1670           aNameList.append( aRefName );
1671           cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1672         }
1673         else
1674           aNameList.append(anIO->getName());
1675         objectCount++;
1676       }
1677
1678       if( aParentComponent.isNull() )
1679         aParentComponent = cur;
1680       else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1681         aParentComponent = "";
1682     }
1683
1684     if ( objectCount == 0 )
1685       return; // No Valid Objects Selected
1686
1687     if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() )  {
1688       SUIT_MessageBox::warning( SMESHGUI::desktop(),
1689                                 QObject::tr("ERR_ERROR"),
1690                                 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1691       return;
1692     }
1693     // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1694     if (SUIT_MessageBox::warning
1695         (SMESHGUI::desktop(),
1696          QObject::tr("SMESH_WRN_WARNING"),
1697          QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1698          SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1699          SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1700       return;
1701
1702     SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1703
1704     // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1705     // then treat them all starting from the deepest objects (at list back)
1706     std::list< _PTR(SObject) > listSO;
1707     SALOME_ListIteratorOfListIO It(selected);
1708     for( ; It.More(); It.Next()) // loop on selected IO's
1709     {
1710       Handle(SALOME_InteractiveObject) IObject = It.Value();
1711       if(IObject->hasEntry()) {
1712         _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1713
1714         // disable removal of "SMESH" component object
1715         if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1716           anIOR = anAttr;
1717           if ( engineIOR() == anIOR->Value().c_str() )
1718             continue;
1719         }
1720         //Check the referenced object
1721         _PTR(SObject) aRefSObject;
1722         if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1723           aSO = aRefSObject; // Delete main Object instead of reference
1724
1725         listSO.push_back( aSO );
1726         std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1727         for ( ; itSO != listSO.end(); ++itSO ) {
1728           _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1729           for (it->InitEx(false); it->More(); it->Next())
1730             listSO.push_back( it->Value() );
1731         }
1732       }
1733     }
1734     // Check if none of objects to delete is referred from outside
1735     std::list< _PTR(SObject) >::reverse_iterator ritSO;
1736     for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1737     {
1738       _PTR(SObject) SO = *ritSO;
1739       if ( !SO ) continue;
1740       std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO  );
1741       for (size_t i = 0; i < aReferences.size(); i++) {
1742         _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1743         std::string type = aComponent->ComponentDataType();
1744         if ( type != "SMESH" )
1745         {
1746           SUIT_MessageBox::warning( anApp->desktop(),
1747                                     QObject::tr("WRN_WARNING"),
1748                                     QObject::tr("DEP_OBJECT") );
1749           return; // outside SMESH, there is an object depending on a SMESH object
1750         }
1751       }
1752     }
1753
1754     // Treat SO's in the list starting from the back
1755     aStudyBuilder->NewCommand();  // There is a transaction
1756     for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1757     {
1758       _PTR(SObject) SO = *ritSO;
1759       if ( !SO ) continue;
1760       std::string anEntry = SO->GetID();
1761
1762       /** Erase graphical object **/
1763       if(SO->FindAttribute(anAttr, "AttributeIOR")){
1764         ViewManagerList aViewMenegers = anApp->viewManagers();
1765         ViewManagerList::const_iterator it = aViewMenegers.begin();
1766         for( ; it != aViewMenegers.end(); it++) {
1767           SUIT_ViewManager* vm = *it;
1768           int nbSf = vm ? vm->getViewsCount() : 0;
1769           if(vm) {
1770             QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1771             for(int i = 0; i < nbSf; i++){
1772               SUIT_ViewWindow *sf = aViews[i];
1773               if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1774                 SMESH::RemoveActor(sf,anActor);
1775               }
1776             }
1777           }
1778         }
1779       }
1780       /** Remove an object from data structures **/
1781       SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1782       SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1783       if ( !aGroup->_is_nil() ) {                          // DELETE GROUP
1784         SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1785         aMesh->RemoveGroup( aGroup );
1786       }
1787       else if ( !aSubMesh->_is_nil() ) {                   // DELETE SUBMESH
1788         SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1789         aMesh->RemoveSubMesh( aSubMesh );
1790
1791         _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1792         if (aMeshSO)
1793           SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1794       }
1795       else {
1796         Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1797           ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1798         QString objType = CheckTypeObject(IObject);
1799         if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1800           SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1801           aStudyBuilder->RemoveObjectWithChildren( SO );
1802         }
1803         else {// default action: remove SObject from the study
1804               // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1805               //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1806               //op->start();
1807           aStudyBuilder->RemoveObjectWithChildren( SO );
1808           //op->finish();
1809         }
1810       }
1811     } /* listSO back loop */
1812
1813     aStudyBuilder->CommitCommand();
1814
1815     /* Clear any previous selection */
1816     SALOME_ListIO l1;
1817     aSel->setSelectedObjects( l1 );
1818
1819     SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1820   }
1821 //} namespace
1822
1823 extern "C" {
1824   SMESHGUI_EXPORT CAM_Module* createModule()
1825   {
1826     return new SMESHGUI();
1827   }
1828
1829   SMESHGUI_EXPORT  char* getModuleVersion() {
1830     return (char*)SMESH_VERSION_STR;
1831   }
1832 }
1833
1834 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1835
1836 //=============================================================================
1837 /*!
1838  *
1839  */
1840 //=============================================================================
1841 SMESHGUI::SMESHGUI() :
1842 SalomeApp_Module( "SMESH" ),
1843 LightApp_Module( "SMESH" )
1844 {
1845   if ( CORBA::is_nil( myComponentSMESH ) )
1846   {
1847     CORBA::Boolean anIsEmbeddedMode;
1848     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1849     MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1850
1851     //  0019923: EDF 765 SMESH : default values of hypothesis
1852     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1853     int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1854     myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1855     nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1856     myComponentSMESH->SetDefaultNbSegments( nbSeg );
1857
1858     const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1859     for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1860       if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1861       {
1862         QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1863         myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1864       }
1865   }
1866
1867   myActiveDialogBox = 0;
1868   myFilterLibraryDlg = 0;
1869   myState = -1;
1870   myDisplayer = 0;
1871
1872   myEventCallbackCommand = vtkCallbackCommand::New();
1873   myEventCallbackCommand->Delete();
1874   myEventCallbackCommand->SetClientData( this );
1875   myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1876   myPriority = 0.0;
1877
1878   SMESH::GetFilterManager();
1879   SMESH::GetPattern();
1880   SMESH::GetMeasurements();
1881
1882   /* load resources for all available meshers */
1883   SMESH::InitAvailableHypotheses();
1884 }
1885
1886 //=============================================================================
1887 /*!
1888  *
1889  */
1890 //=============================================================================
1891 SMESHGUI::~SMESHGUI()
1892 {
1893 #ifdef WITHGENERICOBJ
1894   SMESH::GetFilterManager()->UnRegister();
1895   SMESH::GetMeasurements()->UnRegister();
1896 #endif
1897   SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1898   SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1899 }
1900
1901 //=============================================================================
1902 /*!
1903  *
1904  */
1905 //=============================================================================
1906 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1907 {
1908   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1909   if( anApp )
1910     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1911   else
1912     return 0;
1913 }
1914
1915 //=============================================================================
1916 /*!
1917  *
1918  */
1919 //=============================================================================
1920 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1921 {
1922   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1923   if ( !resMgr )
1924     return false;
1925
1926   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
1927   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1928   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1929   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1930   return autoUpdate && !exceeded;
1931 }
1932
1933 //=============================================================================
1934 /*!
1935  *
1936  */
1937 //=============================================================================
1938 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1939 {
1940   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1941 }
1942
1943 //=============================================================================
1944 /*!
1945  *
1946  */
1947 //=============================================================================
1948 SMESHGUI* SMESHGUI::GetSMESHGUI()
1949 {
1950   SMESHGUI* smeshMod = 0;
1951   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1952   if ( app )
1953   {
1954     CAM_Module* module = app->module( "Mesh" );
1955     smeshMod = dynamic_cast<SMESHGUI*>( module );
1956   }
1957
1958   if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1959   {
1960     SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1961     if ( study )
1962     {
1963       _PTR(Study) aStudy = study->studyDS();
1964       if ( aStudy )
1965         GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
1966     }
1967   }
1968
1969   return smeshMod;
1970 }
1971
1972 extern "C"
1973 {
1974   Standard_EXPORT SMESHGUI* GetComponentGUI()
1975   {
1976     return SMESHGUI::GetSMESHGUI();
1977   }
1978 }
1979
1980 //=============================================================================
1981 /*!
1982  *
1983  */
1984 //=============================================================================
1985 void SMESHGUI::SetState(int aState)
1986 {
1987   myState = aState;
1988 }
1989
1990 //=============================================================================
1991 /*!
1992  *
1993  */
1994 //=============================================================================
1995 void SMESHGUI::ResetState()
1996 {
1997   myState = -1;
1998 }
1999
2000 //=============================================================================
2001 /*!
2002  *
2003  */
2004 //=============================================================================
2005 void SMESHGUI::EmitSignalDeactivateDialog()
2006 {
2007   emit SignalDeactivateActiveDialog();
2008 }
2009
2010 //=============================================================================
2011 /*!
2012  *
2013  */
2014 //=============================================================================
2015 void SMESHGUI::EmitSignalStudyFrameChanged()
2016 {
2017   emit SignalStudyFrameChanged();
2018 }
2019
2020 //=============================================================================
2021 /*!
2022  *
2023  */
2024 //=============================================================================
2025 void SMESHGUI::EmitSignalCloseAllDialogs()
2026 {
2027   emit SignalCloseAllDialogs();
2028 }
2029
2030 //=============================================================================
2031 /*!
2032  *
2033  */
2034 //=============================================================================
2035 void SMESHGUI::EmitSignalVisibilityChanged()
2036 {
2037   emit SignalVisibilityChanged();
2038 }
2039
2040 //=============================================================================
2041 /*!
2042  *
2043  */
2044 //=============================================================================
2045 QDialog *SMESHGUI::GetActiveDialogBox()
2046 {
2047   return myActiveDialogBox;
2048 }
2049
2050 //=============================================================================
2051 /*!
2052  *
2053  */
2054 //=============================================================================
2055 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2056 {
2057   myActiveDialogBox = (QDialog *) aDlg;
2058   return;
2059 }
2060
2061 //=============================================================================
2062 /*!
2063  *
2064  */
2065 //=============================================================================
2066 SUIT_Desktop* SMESHGUI::desktop()
2067 {
2068   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2069   if( app )
2070     return app->desktop();
2071   else
2072     return 0;
2073 }
2074
2075 //=============================================================================
2076 /*!
2077  *
2078  */
2079 //=============================================================================
2080 SalomeApp_Study* SMESHGUI::activeStudy()
2081 {
2082   SUIT_Application* app = SUIT_Session::session()->activeApplication();
2083   if( app )
2084     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2085   else
2086     return NULL;
2087 }
2088
2089 //=============================================================================
2090 /*!
2091  *
2092  */
2093 //=============================================================================
2094 void SMESHGUI::Modified( bool theIsUpdateActions )
2095 {
2096   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2097     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2098       appStudy->Modified();
2099       if( theIsUpdateActions )
2100         app->updateActions();
2101     }
2102   }
2103 }
2104
2105 //=============================================================================
2106 /*!
2107  *
2108  */
2109 //=============================================================================
2110 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2111 {
2112   /* Here the position is on the bottom right corner - 10 */
2113   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2114   aDlg->adjustSize();
2115   SUIT_Desktop *PP = desktop();
2116   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2117   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2118   return true;
2119 }
2120
2121 //=============================================================================
2122 /*!
2123  *
2124  */
2125 //=============================================================================
2126 static int isStudyLocked(_PTR(Study) theStudy){
2127   return theStudy->GetProperties()->IsLocked();
2128 }
2129
2130 static bool checkLock(_PTR(Study) theStudy) {
2131   if (isStudyLocked(theStudy)) {
2132     SUIT_MessageBox::warning( SMESHGUI::desktop(),
2133                               QObject::tr("WRN_WARNING"),
2134                               QObject::tr("WRN_STUDY_LOCKED") );
2135     return true;
2136   }
2137   return false;
2138 }
2139
2140 //=======================================================================
2141 //function : CheckActiveStudyLocked
2142 //purpose  :
2143 //=======================================================================
2144
2145 bool SMESHGUI::isActiveStudyLocked()
2146 {
2147   _PTR(Study) aStudy = activeStudy()->studyDS();
2148   return checkLock( aStudy );
2149 }
2150
2151 //=============================================================================
2152 /*!
2153  *
2154  */
2155 //=============================================================================
2156 bool SMESHGUI::OnGUIEvent( int theCommandID )
2157 {
2158   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2159   if( !anApp )
2160     return false;
2161
2162   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2163   SUIT_ResourceMgr* mgr = resourceMgr();
2164   if( !mgr )
2165     return false;
2166
2167   if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2168     GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2169   }
2170
2171   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2172   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2173
2174   //QAction* act = action( theCommandID );
2175
2176   switch (theCommandID) {
2177   case 33:                                      // DELETE
2178     if(checkLock(aStudy)) break;
2179     OnEditDelete();
2180     break;
2181
2182   case 116:
2183   case 115:
2184   case 117:
2185   case 118:
2186   case 113:
2187   case 112:
2188   case 111:                                     // IMPORT
2189     {
2190       if(checkLock(aStudy)) break;
2191       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2192       break;
2193     }
2194
2195   case 150:    //MED FILE INFORMATION
2196     {
2197       SALOME_ListIO selected;
2198       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2199       if( aSel )
2200         aSel->selectedObjects( selected );
2201       if( selected.Extent() )
2202       {
2203         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2204         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2205         if ( !aMesh->_is_nil() )
2206         {
2207           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2208           dlg.exec();
2209         }
2210       }
2211       break;
2212     }
2213
2214   case 122:                                     // EXPORT MED
2215   case 121:
2216   case 123:
2217   case 124:
2218   case 125:
2219   case 126:
2220   case 140:
2221   case 141:
2222   case 142:
2223   case 143:
2224   case 144:
2225   case 145:
2226   case 146:
2227   case 147:
2228     {
2229       ::ExportMeshToFile(theCommandID);
2230       break;
2231     }
2232
2233   case 200:                                     // SCALAR BAR
2234     {
2235       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2236       SALOME_ListIO selected;
2237       if( aSel )
2238         aSel->selectedObjects( selected );
2239
2240       if( selected.Extent() ) {
2241         Handle(SALOME_InteractiveObject) anIO = selected.First();
2242         if( anIO->hasEntry() ) {
2243           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2244             anActor->SetControlMode( SMESH_Actor::eNone );
2245 #ifndef DISABLE_PLOT2DVIEWER
2246             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2247 #endif
2248           }
2249         }
2250       }
2251       break;
2252     }
2253   case 201:
2254     {
2255       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2256       break;
2257     }
2258   case 2021:
2259     {
2260       // dump control distribution data to the text file
2261       ::SaveDistribution();
2262       break;
2263     }
2264
2265   case 2022:
2266     {
2267       // show/ distribution
2268       ::ShowDistribution();
2269       break;
2270     }
2271
2272 #ifndef DISABLE_PLOT2DVIEWER
2273   case 2023:
2274     {
2275       // plot distribution
2276       ::PlotDistribution();
2277       break;
2278     }
2279 #endif
2280
2281     // Auto-color
2282   case 1136:
2283     ::AutoColor();
2284   break;
2285
2286   case 1137:
2287     ::DisableAutoColor();
2288   break;
2289
2290   case 1134: // Clipping
2291   case 1133: // Tranparency
2292   case 1132: // Display preferences (colors, shrink size, line width, ...)
2293
2294     // Display Mode
2295   case 215: // Nodes
2296   case 213: // Nodes
2297   case 212: // Nodes
2298   case 211: // Nodes
2299     ::SetDisplayMode(theCommandID, myMarkerMap);
2300   break;
2301
2302   //2D quadratic representation
2303   case 231:
2304   case 232:
2305     ::SetDisplayMode(theCommandID, myMarkerMap);
2306   break;
2307
2308   // Display Entity
2309   case 216: // 0D elements
2310   case 217: // Edges
2311   case 218: // Faces
2312   case 219: // Volumes
2313   case 220: // All Entity
2314   case 222: // Balls
2315     ::SetDisplayEntity(theCommandID);
2316   break;
2317
2318   case 221: // Orientation of faces
2319     {
2320       LightApp_SelectionMgr* mgr = selectionMgr();
2321       SALOME_ListIO selected; mgr->selectedObjects( selected );
2322
2323       SALOME_ListIteratorOfListIO it(selected);
2324       for( ; it.More(); it.Next()) {
2325         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2326         if(anIObject->hasEntry()) {
2327           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2328             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2329           }
2330         }
2331       }
2332       break;
2333     }
2334
2335   case 214:                                     // UPDATE
2336     {
2337       if(checkLock(aStudy)) break;
2338       try {
2339 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2340         OCC_CATCH_SIGNALS;
2341 #endif
2342         SMESH::UpdateView();
2343       }
2344       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2345         SMESH::OnVisuException();
2346       }
2347       catch (...) { // PAL16774 (Crash after display of many groups)
2348         SMESH::OnVisuException();
2349       }
2350
2351       SALOME_ListIO l;
2352       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2353       aSel->selectedObjects( l );
2354       aSel->setSelectedObjects( l );
2355       break;
2356     }
2357
2358   case 300:                                     // ERASE
2359   case 301:                                     // DISPLAY
2360   case 302:                                     // DISPLAY ONLY
2361     {
2362       SMESH::EDisplaing anAction;
2363       switch (theCommandID) {
2364       case 300: anAction = SMESH::eErase; break;
2365       case 301: anAction = SMESH::eDisplay; break;
2366       case 302: anAction = SMESH::eDisplayOnly; break;
2367       }
2368
2369       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2370       SALOME_ListIO sel_objects, to_process;
2371       if (aSel)
2372         aSel->selectedObjects( sel_objects );
2373
2374       if( theCommandID==302 )
2375       {
2376         MESSAGE("anAction = SMESH::eDisplayOnly");
2377         startOperation( myEraseAll );
2378       }
2379
2380       extractContainers( sel_objects, to_process );
2381
2382       try {
2383 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2384         OCC_CATCH_SIGNALS;
2385 #endif
2386         if (vtkwnd) {
2387           SALOME_ListIteratorOfListIO It( to_process );
2388           for ( ; It.More(); It.Next()) {
2389                 MESSAGE("---");
2390             Handle(SALOME_InteractiveObject) IOS = It.Value();
2391             if (IOS->hasEntry()) {
2392                 MESSAGE("---");
2393               if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2394                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2395                 break; // PAL16774 (Crash after display of many groups)
2396               }
2397               if (anAction == SMESH::eDisplayOnly)
2398               {
2399                 MESSAGE("anAction = SMESH::eDisplayOnly");
2400                 anAction = SMESH::eDisplay;
2401               }
2402             }
2403           }
2404         }
2405
2406         // PAL13338 + PAL15161 -->
2407         if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2408                 MESSAGE("anAction = SMESH::eDisplayOnly");
2409           SMESH::UpdateView();
2410           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2411         }
2412         // PAL13338 + PAL15161 <--
2413       }
2414       catch (...) { // PAL16774 (Crash after display of many groups)
2415         SMESH::OnVisuException();
2416       }
2417
2418       if (anAction == SMESH::eErase) {
2419         MESSAGE("anAction == SMESH::eErase");
2420         SALOME_ListIO l1;
2421         aSel->setSelectedObjects( l1 );
2422       }
2423       else
2424         aSel->setSelectedObjects( to_process );
2425
2426       break;
2427     }
2428
2429   case 4000:                                    // NODES
2430     {
2431       if(checkLock(aStudy)) break;
2432
2433       if ( vtkwnd ) {
2434         EmitSignalDeactivateDialog();
2435
2436         ( new SMESHGUI_NodesDlg( this ) )->show();
2437       }
2438       else {
2439         SUIT_MessageBox::warning(desktop(),
2440                                  tr("SMESH_WRN_WARNING"),
2441                                  tr("SMESH_WRN_VIEWER_VTK"));
2442       }
2443       break;
2444     }
2445
2446   case 2151:  // FILTER
2447   {
2448     if ( vtkwnd )
2449     {
2450       EmitSignalDeactivateDialog();
2451       ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2452     }
2453     break;
2454   }
2455
2456   case 701: // COMPUTE MESH
2457   case 711: // PRECOMPUTE MESH
2458   case 712: // EVALUATE MESH
2459   case 713: // MESH ORDER
2460   case 702: // Create mesh
2461   case 703: // Create sub-mesh
2462   case 704: // Edit mesh/sub-mesh
2463     startOperation( theCommandID );
2464     break;
2465   case 705: // copy mesh
2466     {
2467       if (checkLock(aStudy)) break;
2468       EmitSignalDeactivateDialog();
2469       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2470     }
2471     break;
2472   case 710: // Build compound mesh
2473     {
2474       if (checkLock(aStudy)) break;
2475       EmitSignalDeactivateDialog();
2476       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2477     }
2478     break;
2479
2480   case 407: // DIAGONAL INVERSION
2481   case 408: // Delete diagonal
2482     {
2483       if ( !vtkwnd )
2484       {
2485         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2486                                   tr( "NOT_A_VTK_VIEWER" ) );
2487         break;
2488       }
2489
2490       if ( checkLock( aStudy ) )
2491         break;
2492
2493       /*Standard_Boolean aRes;
2494       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2495       if ( aMesh->_is_nil() )
2496       {
2497         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2498           tr( "SMESH_BAD_SELECTION" ) );
2499         break;
2500       }
2501       */
2502       EmitSignalDeactivateDialog();
2503       if ( theCommandID == 407 )
2504         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2505       else
2506         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2507       break;
2508     }
2509   case 409: // Change orientation
2510   case 410: // Union of triangles
2511   case 411: // Cutting of quadrangles
2512   case 419: // Splitting volumes into tetrahedra
2513     {
2514       if ( !vtkwnd )
2515       {
2516         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2517                                   tr( "NOT_A_VTK_VIEWER" ) );
2518         break;
2519       }
2520
2521       if ( checkLock( aStudy ) )
2522         break;
2523
2524       EmitSignalDeactivateDialog();
2525       SMESHGUI_MultiEditDlg* aDlg = NULL;
2526       if ( theCommandID == 409 )
2527         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2528       else if ( theCommandID == 410 )
2529         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2530       else if ( theCommandID == 419 )
2531         aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2532       else
2533         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2534
2535       aDlg->show();
2536       break;
2537     }
2538   case 412: // Smoothing
2539     {
2540       if(checkLock(aStudy)) break;
2541       if( vtkwnd ) {
2542         EmitSignalDeactivateDialog();
2543         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2544       }
2545       else {
2546         SUIT_MessageBox::warning(desktop(),
2547                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2548       }
2549       break;
2550     }
2551   case 413: // Extrusion
2552     {
2553       if (checkLock(aStudy)) break;
2554       if (vtkwnd) {
2555         EmitSignalDeactivateDialog();
2556         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2557       } else {
2558         SUIT_MessageBox::warning(desktop(),
2559                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2560       }
2561       break;
2562     }
2563   case 414: // Revolution
2564     {
2565       if(checkLock(aStudy)) break;
2566       if( vtkwnd ) {
2567         EmitSignalDeactivateDialog();
2568         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2569       }
2570       else {
2571         SUIT_MessageBox::warning(desktop(),
2572                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2573       }
2574       break;
2575     }
2576   case 415: // Pattern mapping
2577     {
2578       if ( checkLock( aStudy ) )
2579         break;
2580       if ( vtkwnd )
2581       {
2582         EmitSignalDeactivateDialog();
2583         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2584       }
2585       else {
2586         SUIT_MessageBox::warning(desktop(),
2587                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2588       }
2589       break;
2590     }
2591   case 416: // Extrusion along a path
2592     {
2593       if (checkLock(aStudy)) break;
2594       if (vtkwnd) {
2595         EmitSignalDeactivateDialog();
2596         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2597       } else {
2598         SUIT_MessageBox::warning(desktop(),
2599                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2600       }
2601       break;
2602     }
2603   case 417: // Convert mesh to quadratic
2604   case 418: // create 2D mesh from 3D
2605   case 420: // Reorient faces
2606   case 806: // CREATE GEO GROUP
2607     {
2608       startOperation( theCommandID );
2609       break;
2610     }
2611   case 801:                                     // CREATE GROUP
2612     {
2613       if ( !vtkwnd )
2614       {
2615         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2616                                   tr( "NOT_A_VTK_VIEWER" ) );
2617         break;
2618       }
2619
2620       if(checkLock(aStudy)) break;
2621       EmitSignalDeactivateDialog();
2622       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2623
2624       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2625       SALOME_ListIO selected;
2626       if( aSel )
2627         aSel->selectedObjects( selected );
2628
2629       int nbSel = selected.Extent();
2630       if (nbSel == 1) {
2631         // check if mesh is selected
2632         aMesh = SMESH::GetMeshByIO( selected.First() );
2633       }
2634       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2635       aDlg->show();
2636       break;
2637     }
2638
2639   case 802:                                     // CONSTRUCT GROUP
2640     {
2641       if ( !vtkwnd )
2642       {
2643         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2644                                   tr( "NOT_A_VTK_VIEWER" ) );
2645         break;
2646       }
2647
2648       if(checkLock(aStudy)) break;
2649       EmitSignalDeactivateDialog();
2650
2651       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2652       SALOME_ListIO selected;
2653       if( aSel )
2654         aSel->selectedObjects( selected );
2655
2656       int nbSel = selected.Extent();
2657       if (nbSel == 1) {
2658         // check if submesh is selected
2659         Handle(SALOME_InteractiveObject) IObject = selected.First();
2660         if (IObject->hasEntry()) {
2661           _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2662           if( aSObj ) {
2663             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2664             if (!aSubMesh->_is_nil()) {
2665               try {
2666                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2667                 // get submesh elements list by types
2668                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2669                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2670                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2671                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2672                 // create group for each type o elements
2673                 QString aName = IObject->getName();
2674                 QStringList anEntryList;
2675                 if (aNodes->length() > 0) {
2676                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2677                   aGroup->Add(aNodes.inout());
2678                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2679                     anEntryList.append( aSObject->GetID().c_str() );
2680                 }
2681                 if (aEdges->length() > 0) {
2682                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2683                   aGroup->Add(aEdges.inout());
2684                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2685                     anEntryList.append( aSObject->GetID().c_str() );
2686                 }
2687                 if (aFaces->length() > 0) {
2688                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2689                   aGroup->Add(aFaces.inout());
2690                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2691                     anEntryList.append( aSObject->GetID().c_str() );
2692                 }
2693                 if (aVolumes->length() > 0) {
2694                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2695                   aGroup->Add(aVolumes.inout());
2696                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2697                     anEntryList.append( aSObject->GetID().c_str() );
2698                 }
2699                 updateObjBrowser();
2700                 anApp->browseObjects( anEntryList );
2701               }
2702               catch(const SALOME::SALOME_Exception & S_ex){
2703                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2704               }
2705             }
2706           }
2707         }
2708       }
2709       else if(nbSel==0) {
2710         SUIT_MessageBox::warning(desktop(),
2711                                  tr("SMESH_WRN_WARNING"),
2712                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2713       }
2714       break;
2715     }
2716
2717   case 803:                                     // EDIT GROUP
2718     {
2719       if ( !vtkwnd )
2720       {
2721         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2722                                   tr( "NOT_A_VTK_VIEWER" ) );
2723         break;
2724       }
2725
2726       if(checkLock(aStudy)) break;
2727       EmitSignalDeactivateDialog();
2728
2729       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2730       SALOME_ListIO selected;
2731       if( aSel )
2732         aSel->selectedObjects( selected );
2733
2734       SALOME_ListIteratorOfListIO It (selected);
2735       int nbSelectedGroups = 0;
2736       for ( ; It.More(); It.Next() )
2737       {
2738         SMESH::SMESH_GroupBase_var aGroup =
2739           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2740         if (!aGroup->_is_nil()) {
2741           nbSelectedGroups++;
2742           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2743           aDlg->show();
2744         }
2745       }
2746       if (nbSelectedGroups == 0)
2747         {
2748           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2749           aDlg->show();
2750         }
2751       break;
2752     }
2753
2754   case 804:                                     // Add elements to group
2755     {
2756       if(checkLock(aStudy)) break;
2757       if (myState == 800) {
2758         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2759         if (aDlg) aDlg->onAdd();
2760       }
2761       break;
2762     }
2763
2764   case 805:                                     // Remove elements from group
2765     {
2766       if(checkLock(aStudy)) break;
2767       if (myState == 800) {
2768         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2769         if (aDlg) aDlg->onRemove();
2770       }
2771       break;
2772     }
2773
2774   case 815:                                     // Edit GEOM GROUP as standalone
2775     {
2776       if ( !vtkwnd )
2777       {
2778         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2779                                   tr( "NOT_A_VTK_VIEWER" ) );
2780         break;
2781       }
2782
2783       if(checkLock(aStudy)) break;
2784       EmitSignalDeactivateDialog();
2785
2786       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2787       SALOME_ListIO selected;
2788       if( aSel )
2789         aSel->selectedObjects( selected );
2790
2791       SALOME_ListIteratorOfListIO It (selected);
2792       for ( ; It.More(); It.Next() )
2793       {
2794         SMESH::SMESH_GroupOnGeom_var aGroup =
2795           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2796         if (!aGroup->_is_nil()) {
2797           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2798           aDlg->show();
2799         }
2800         else
2801         {
2802           SMESH::SMESH_GroupOnFilter_var aGroup =
2803             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2804           if (!aGroup->_is_nil()) {
2805             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2806             aDlg->show();
2807           }
2808         }
2809       }
2810       break;
2811     }
2812
2813     case 810: // Union Groups
2814     case 811: // Intersect groups
2815     case 812: // Cut groups
2816     {
2817       if ( !vtkwnd )
2818       {
2819         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2820                                   tr( "NOT_A_VTK_VIEWER" ) );
2821         break;
2822       }
2823
2824       if ( checkLock( aStudy ) )
2825         break;
2826
2827       EmitSignalDeactivateDialog();
2828
2829       SMESHGUI_GroupOpDlg* aDlg = 0;
2830       if ( theCommandID == 810 )
2831         aDlg = new SMESHGUI_UnionGroupsDlg( this );
2832       else if ( theCommandID == 811 )
2833         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2834       else
2835         aDlg = new SMESHGUI_CutGroupsDlg( this );
2836
2837       aDlg->show();
2838
2839       break;
2840     }
2841
2842     case 814: // Create groups of entities from existing groups of superior dimensions
2843     {
2844       if ( checkLock( aStudy ) )
2845         break;
2846
2847       EmitSignalDeactivateDialog();
2848       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2849       aDlg->show();
2850
2851       break;
2852     }
2853
2854     case 813: // Delete groups with their contents
2855     {
2856       if ( !vtkwnd )
2857       {
2858         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2859                                   tr( "NOT_A_VTK_VIEWER" ) );
2860         break;
2861       }
2862
2863       if ( checkLock( aStudy ) )
2864         break;
2865
2866       EmitSignalDeactivateDialog();
2867
2868       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2869       break;
2870     }
2871
2872   case 900:                                     // MESH INFOS
2873   case 903:                                     // WHAT IS
2874     {
2875       int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2876       EmitSignalDeactivateDialog();
2877       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2878       SALOME_ListIO selected;
2879       if( aSel )
2880         aSel->selectedObjects( selected );
2881
2882       if ( selected.Extent() > 1 ) { // a dlg for each IO
2883         SALOME_ListIteratorOfListIO It( selected );
2884         for ( ; It.More(); It.Next() ) {
2885           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2886           dlg->showInfo( It.Value() );
2887           dlg->show();
2888         }
2889       }
2890       else {
2891         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2892         dlg->show();
2893       }
2894       break;
2895     }
2896
2897   case 904:                                     // FIND ELEM
2898     {
2899       startOperation( theCommandID );
2900       break;
2901     }
2902
2903   case 1100:                                    // EDIT HYPOTHESIS
2904     {
2905       if(checkLock(aStudy)) break;
2906
2907       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2908       SALOME_ListIO selected;
2909       if( aSel )
2910         aSel->selectedObjects( selected );
2911
2912       int nbSel = selected.Extent();
2913
2914       if (nbSel == 1) {
2915         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2916         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2917
2918         /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2919         /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects                   */
2920         /* Warning : however by internal mechanism all subMeshes icons are changed !                     */
2921         if ( !aHypothesis->_is_nil() )
2922         {
2923           // BUG 0020378
2924           //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2925           SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2926           if (aCreator) {
2927             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2928           }
2929           else
2930           {
2931             // report error
2932           }
2933         }
2934       }
2935       break;
2936     }
2937   case 1102:                                    // REMOVE HYPOTHESIS / ALGORITHMS
2938     {
2939       if(checkLock(aStudy)) break;
2940       SUIT_OverrideCursor wc;
2941
2942       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2943       SALOME_ListIO selected;
2944       if( aSel )
2945         aSel->selectedObjects( selected, QString::null, false );
2946
2947       SALOME_ListIteratorOfListIO It(selected);
2948       for (int i = 0; It.More(); It.Next(), i++) {
2949         Handle(SALOME_InteractiveObject) IObject = It.Value();
2950         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2951       }
2952       SALOME_ListIO l1;
2953       aSel->setSelectedObjects( l1 );
2954       updateObjBrowser();
2955       break;
2956     }
2957
2958   case 4008:                                    // BALL
2959   case 4009:                                    // ELEM0D
2960   case 4010:                                    // EDGE
2961   case 4021:                                    // TRIANGLE
2962   case 4022:                                    // QUAD
2963   case 4023:                                    // POLYGON
2964   case 4031:                                    // TETRA
2965   case 4032:                                    // HEXA
2966   case 4133:                                    // PENTA
2967   case 4134:                                    // PYRAMID
2968   case 4135:                                    // OCTA12
2969     {
2970       if(checkLock(aStudy)) break;
2971       if ( vtkwnd ) {
2972         EmitSignalDeactivateDialog();
2973         SMDSAbs_EntityType type = SMDSEntity_Edge;
2974         switch (theCommandID) {
2975         case 4008: type = SMDSEntity_Ball;            break;
2976         case 4009: type = SMDSEntity_0D;              break;
2977         case 4021: type = SMDSEntity_Triangle;        break;
2978         case 4022: type = SMDSEntity_Quadrangle;      break;
2979         case 4031: type = SMDSEntity_Tetra;           break;
2980         case 4023: type = SMDSEntity_Polygon;         break;
2981         case 4032: type = SMDSEntity_Hexa;            break;
2982         case 4133: type = SMDSEntity_Penta;           break;
2983         case 4134: type = SMDSEntity_Pyramid;         break;
2984         case 4135: type = SMDSEntity_Hexagonal_Prism; break;
2985         default:;
2986         }
2987         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
2988       }
2989       else {
2990         SUIT_MessageBox::warning(desktop(),
2991                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2992       }
2993       break;
2994     }
2995   case 4033:                                    // POLYHEDRON
2996     {
2997       if(checkLock(aStudy)) break;
2998       if ( vtkwnd ) {
2999         EmitSignalDeactivateDialog();
3000         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3001       }
3002       else {
3003         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3004                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3005       }
3006       break;
3007     }
3008   case 4034:     // QUADRATIC EDGE
3009   case 4035:     // QUADRATIC TRIANGLE
3010   case 4036:     // QUADRATIC QUADRANGLE
3011   case 4136:     // BIQUADRATIC QUADRANGLE
3012   case 4037:     // QUADRATIC TETRAHEDRON
3013   case 4038:     // QUADRATIC PYRAMID
3014   case 4039:     // QUADRATIC PENTAHEDRON
3015   case 4040:     // QUADRATIC HEXAHEDRON
3016   case 4140:     // TRIQUADRATIC HEXAHEDRON
3017     {
3018       if(checkLock(aStudy)) break;
3019       if ( vtkwnd ) {
3020         EmitSignalDeactivateDialog();
3021         SMDSAbs_EntityType type;
3022
3023         switch (theCommandID) {
3024         case 4034:
3025           type = SMDSEntity_Quad_Edge; break;
3026         case 4035:
3027           type = SMDSEntity_Quad_Triangle; break;
3028         case 4036:
3029           type = SMDSEntity_Quad_Quadrangle; break;
3030         case 4136:
3031           type = SMDSEntity_BiQuad_Quadrangle; break;
3032         case 4037:
3033           type = SMDSEntity_Quad_Tetra; break;
3034         case 4038:
3035           type = SMDSEntity_Quad_Pyramid; break;
3036         case 4039:
3037           type = SMDSEntity_Quad_Penta; break;
3038         case 4040:
3039           type = SMDSEntity_Quad_Hexa;
3040         case 4140:
3041           type = SMDSEntity_TriQuad_Hexa;
3042           break;
3043         default:;
3044         }
3045          ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3046       }
3047       else {
3048         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3049                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3050       }
3051       break;
3052     }
3053   case 4041:                                    // REMOVES NODES
3054     {
3055       if(checkLock(aStudy)) break;
3056       if ( vtkwnd ) {
3057         EmitSignalDeactivateDialog();
3058         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3059       }
3060       else {
3061         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3062                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3063       }
3064       break;
3065     }
3066   case 4042:                                    // REMOVES ELEMENTS
3067     {
3068       if(checkLock(aStudy)) break;
3069       if( vtkwnd ) {
3070         EmitSignalDeactivateDialog();
3071         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3072       }
3073       else
3074         {
3075           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3076                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3077         }
3078       break;
3079     }
3080   case 4043: {                                // CLEAR_MESH
3081
3082     if(checkLock(aStudy)) break;
3083
3084     SALOME_ListIO selected;
3085     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3086       aSel->selectedObjects( selected );
3087
3088     SUIT_OverrideCursor wc;
3089     SALOME_ListIteratorOfListIO It (selected);
3090     for ( ; It.More(); It.Next() )
3091     {
3092       Handle(SALOME_InteractiveObject) IOS = It.Value();
3093       SMESH::SMESH_Mesh_var aMesh =
3094         SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3095       if ( aMesh->_is_nil()) continue;
3096       try {
3097         SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3098         aMesh->Clear();
3099         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3100         SMESH::ModifiedMesh( aMeshSObj, false, true);
3101         // hide groups and submeshes
3102         _PTR(ChildIterator) anIter =
3103           SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3104         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3105         {
3106           _PTR(SObject) so = anIter->Value();
3107           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3108         }
3109       }
3110       catch (const SALOME::SALOME_Exception& S_ex){
3111         wc.suspend();
3112         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3113         wc.resume();
3114       }
3115     }
3116     SMESH::UpdateView();
3117     updateObjBrowser();
3118     break;
3119   }
3120   case 4044:                                     // REMOVE ORPHAN NODES
3121     {
3122       if(checkLock(aStudy)) break;
3123       SALOME_ListIO selected;
3124       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3125         aSel->selectedObjects( selected );
3126       if ( selected.Extent() == 1 ) {
3127         Handle(SALOME_InteractiveObject) anIO = selected.First();
3128         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3129         if ( !aMesh->_is_nil() ) {
3130           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3131                                                     tr( "SMESH_WARNING" ),
3132                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3133                                                     SUIT_MessageBox::Yes |
3134                                                     SUIT_MessageBox::No,
3135                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3136           if( confirm ) {
3137             try {
3138               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3139               int removed = aMeshEditor->RemoveOrphanNodes();
3140               SUIT_MessageBox::information(SMESHGUI::desktop(),
3141                                            tr("SMESH_INFORMATION"),
3142                                            tr("NB_NODES_REMOVED").arg(removed));
3143               if ( removed > 0 ) {
3144                 SMESH::UpdateView();
3145                 SMESHGUI::Modified();
3146               }
3147             }
3148             catch (const SALOME::SALOME_Exception& S_ex) {
3149               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3150             }
3151             catch (...) {
3152             }
3153           }
3154         }
3155       }
3156       break;
3157     }
3158   case 4051:                                    // RENUMBERING NODES
3159     {
3160       if(checkLock(aStudy)) break;
3161       if( vtkwnd ) {
3162         EmitSignalDeactivateDialog();
3163         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3164       }
3165       else
3166         {
3167           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3168                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3169         }
3170       break;
3171     }
3172   case 4052:                                    // RENUMBERING ELEMENTS
3173     {
3174       if(checkLock(aStudy)) break;
3175       if ( vtkwnd ) {
3176         EmitSignalDeactivateDialog();
3177         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3178       }
3179       else
3180         {
3181           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3182                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3183         }
3184       break;
3185     }
3186   case 4061:                                   // TRANSLATION
3187     {
3188       if(checkLock(aStudy)) break;
3189       if ( vtkwnd ) {
3190         EmitSignalDeactivateDialog();
3191         ( new SMESHGUI_TranslationDlg( this ) )->show();
3192       }
3193       else {
3194         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3195                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3196       }
3197       break;
3198     }
3199   case 4062:                                   // ROTATION
3200     {
3201       if(checkLock(aStudy)) break;
3202       if( vtkwnd ) {
3203         EmitSignalDeactivateDialog();
3204         ( new SMESHGUI_RotationDlg( this ) )->show();
3205       }
3206       else {
3207         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3208                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3209       }
3210       break;
3211     }
3212   case 4063:                                   // SYMMETRY
3213     {
3214       if(checkLock(aStudy)) break;
3215       if(vtkwnd) {
3216         EmitSignalDeactivateDialog();
3217         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3218       }
3219       else {
3220         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3221                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3222       }
3223       break;
3224     }
3225   case 4064:                                   // SEWING
3226     {
3227       if(checkLock(aStudy)) break;
3228       if(vtkwnd) {
3229         EmitSignalDeactivateDialog();
3230         ( new SMESHGUI_SewingDlg( this ) )->show();
3231       }
3232       else {
3233         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3234                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3235       }
3236       break;
3237     }
3238   case 4065:                                   // MERGE NODES
3239     {
3240       if(checkLock(aStudy)) break;
3241       if(vtkwnd) {
3242         EmitSignalDeactivateDialog();
3243         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3244       }
3245       else {
3246         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3247                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3248       }
3249       break;
3250     }
3251   case 4066:                                   // MERGE EQUAL ELEMENTS
3252     {
3253       if (checkLock(aStudy)) break;
3254       if (vtkwnd) {
3255         EmitSignalDeactivateDialog();
3256         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3257       } else {
3258         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3259                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3260       }
3261       break;
3262     }
3263
3264   case 4067: // MAKE MESH PASS THROUGH POINT
3265     startOperation( 4067 );
3266     break;
3267
3268   case 4068: // SCALE
3269     {
3270       if(checkLock(aStudy)) break;
3271       if ( vtkwnd ) {
3272         EmitSignalDeactivateDialog();
3273         ( new SMESHGUI_ScaleDlg( this ) )->show();
3274       }
3275       else {
3276         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3277                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3278       }
3279       break;
3280     }
3281
3282   case 4069: // DUPLICATE NODES
3283     {
3284       if(checkLock(aStudy)) break;
3285       if ( vtkwnd ) {
3286         EmitSignalDeactivateDialog();
3287         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3288       }
3289       else {
3290         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3291                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3292       }
3293       break;
3294     }
3295
3296   case 5105: // Library of selection filters
3297   {
3298     static QList<int> aTypes;
3299     if ( aTypes.isEmpty() )
3300     {
3301       aTypes.append( SMESH::NODE );
3302       aTypes.append( SMESH::EDGE );
3303       aTypes.append( SMESH::FACE );
3304       aTypes.append( SMESH::VOLUME );
3305     }
3306     if (!myFilterLibraryDlg)
3307       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3308     else if (myFilterLibraryDlg->isHidden())
3309       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3310     myFilterLibraryDlg->raise();
3311   }
3312   break;
3313
3314   case 6017:                                    // CONTROLS
3315   case 6016:
3316   case 6015:
3317   case 6014:
3318   case 6013:
3319   case 6012:
3320   case 6011:
3321   case 6001:
3322   case 6018:
3323   case 6019:
3324   case 6002:
3325   case 6003:
3326   case 6004:
3327   case 6005:
3328   case 6009:
3329   case 6021:
3330   case 6022:
3331   case 6023:
3332   case 6024:
3333   case 6025:
3334   case 6026:
3335   case 6027:
3336   case 6028:
3337   case 6029:
3338   case 6030:
3339   case 6031:
3340     if ( vtkwnd ) {
3341
3342       LightApp_SelectionMgr* mgr = selectionMgr();
3343       SALOME_ListIO selected; mgr->selectedObjects( selected );
3344
3345       if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3346         _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3347         if ( SO ) {
3348           CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3349           SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( aObject );
3350           SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3351           SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( aObject );
3352           if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3353             ::Control( theCommandID );
3354             break;
3355           }
3356         }
3357       }
3358       SUIT_MessageBox::warning(desktop(),
3359                                tr( "SMESH_WRN_WARNING" ),
3360                                tr( "SMESH_BAD_SELECTION" ) );
3361       break;
3362     }
3363     else {
3364       SUIT_MessageBox::warning(desktop(),
3365                                tr( "SMESH_WRN_WARNING" ),
3366                                tr( "NOT_A_VTK_VIEWER" ) );
3367     }
3368     break;
3369   case 9010:
3370     {
3371       LightApp_SelectionMgr* mgr = selectionMgr();
3372       SALOME_ListIO selected; mgr->selectedObjects( selected );
3373
3374       SALOME_ListIteratorOfListIO it(selected);
3375       for( ; it.More(); it.Next()) {
3376         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3377         if(anIObject->hasEntry()) {
3378           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3379             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3380           }
3381         }
3382       }
3383       break;
3384     }
3385   case 9011:
3386     {
3387       LightApp_SelectionMgr* mgr = selectionMgr();
3388       SALOME_ListIO selected; mgr->selectedObjects( selected );
3389
3390       SALOME_ListIteratorOfListIO it(selected);
3391       for( ; it.More(); it.Next()) {
3392         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3393         if(anIObject->hasEntry())
3394           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3395             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3396           }
3397       }
3398       break;
3399     }
3400   case 501:
3401   case 502:
3402     {
3403       int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3404       EmitSignalDeactivateDialog();
3405       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3406       dlg->show();
3407       break;
3408     }
3409   }
3410
3411   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3412   //updateObjBrowser();
3413   return true;
3414 }
3415
3416 //=============================================================================
3417 /*!
3418  *
3419  */
3420 //=============================================================================
3421 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3422 {
3423   return false;
3424 }
3425
3426 //=============================================================================
3427 /*!
3428  *
3429  */
3430 //=============================================================================
3431 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3432 {
3433   return true;
3434 }
3435
3436 //=============================================================================
3437 /*!
3438  *
3439  */
3440 //=============================================================================
3441 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3442 {
3443   return true;
3444 }
3445
3446 //=============================================================================
3447 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3448  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3449  */
3450 //=============================================================================
3451 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3452                                   SUIT_ViewWindow* wnd )
3453 {
3454   if(theIO->hasEntry()){
3455     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3456     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3457   }
3458 }
3459
3460 //=======================================================================
3461 // function : createSMESHAction
3462 // purpose  :
3463 //=======================================================================
3464 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3465                                   const int key, const bool toggle, const QString& shortcutAction  )
3466 {
3467   QIcon icon;
3468   QWidget* parent = application()->desktop();
3469   SUIT_ResourceMgr* resMgr = resourceMgr();
3470   QPixmap pix;
3471   if ( !icon_id.isEmpty() )
3472     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3473   else
3474     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3475   if ( !pix.isNull() )
3476     icon = QIcon( pix );
3477
3478   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3479           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3480           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3481
3482   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3483                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3484 }
3485
3486 //=======================================================================
3487 // function : createPopupItem
3488 // purpose  :
3489 //=======================================================================
3490 void SMESHGUI::createPopupItem( const int id,
3491                                 const QString& clients,
3492                                 const QString& types,
3493                                 const QString& theRule,
3494                                 const int pId )
3495 {
3496   int parentId = pId;
3497   if( pId!=-1 )
3498     parentId = popupMgr()->actionId( action( pId ) );
3499
3500   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3501     popupMgr()->insert( action( id ), parentId, 0 );
3502
3503   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3504   QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3505   QString rule = "(%1) and (%2) and (%3)";
3506   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3507   if( clients.isEmpty() )
3508     rule = rule.arg( QString( "true" ) );
3509   else
3510     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3511   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3512   rule += theRule;
3513
3514   bool cont = myRules.contains( id );
3515   if( cont )
3516     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3517
3518   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3519   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3520 }
3521
3522 //=======================================================================
3523 // function : initialize
3524 // purpose  :
3525 //=======================================================================
3526 void SMESHGUI::initialize( CAM_Application* app )
3527 {
3528   SalomeApp_Module::initialize( app );
3529
3530 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3531 //   if ( mgr )
3532   /* Automatic Update flag */
3533 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3534
3535   // ----- create actions --------------
3536
3537   //createSMESHAction(  111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3538   createSMESHAction(  112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3539   createSMESHAction(  113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3540   createSMESHAction(  114, "NUM" );
3541   createSMESHAction(  115, "IMPORT_STL"  );
3542   createSMESHAction(  116, "IMPORT_CGNS" );
3543   createSMESHAction(  117, "IMPORT_SAUV" );
3544   createSMESHAction(  118, "IMPORT_GMF"  );
3545   createSMESHAction(  121, "DAT" );
3546   createSMESHAction(  122, "MED" );
3547   createSMESHAction(  123, "UNV" );
3548   createSMESHAction(  140, "STL" );
3549   createSMESHAction(  142, "CGNS");
3550   createSMESHAction(  144, "SAUV");
3551   createSMESHAction(  146, "GMF" );
3552   createSMESHAction(  124, "EXPORT_DAT" );
3553   createSMESHAction(  125, "EXPORT_MED" );
3554   createSMESHAction(  126, "EXPORT_UNV" );
3555   createSMESHAction(  141, "EXPORT_STL" );
3556   createSMESHAction(  143, "EXPORT_CGNS");
3557   createSMESHAction(  145, "EXPORT_SAUV");
3558   createSMESHAction(  147, "EXPORT_GMF" );
3559   createSMESHAction(  150, "FILE_INFO" );
3560   createSMESHAction(   33, "DELETE",          "ICON_DELETE", Qt::Key_Delete );
3561   createSMESHAction( 5105, "SEL_FILTER_LIB" );
3562   createSMESHAction(  701, "COMPUTE",         "ICON_COMPUTE" );
3563   createSMESHAction(  702, "CREATE_MESH",     "ICON_DLG_INIT_MESH" );
3564   createSMESHAction(  703, "CREATE_SUBMESH",  "ICON_DLG_ADD_SUBMESH" );
3565   createSMESHAction(  704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3566   createSMESHAction(  705, "COPY_MESH",       "ICON_COPY_MESH" );
3567   createSMESHAction(  710, "BUILD_COMPOUND",  "ICON_BUILD_COMPOUND" );
3568   createSMESHAction(  711, "PRECOMPUTE",      "ICON_PRECOMPUTE" );
3569   createSMESHAction(  712, "EVALUATE",        "ICON_COMPUTE" );
3570   createSMESHAction(  713, "MESH_ORDER",      "ICON_COMPUTE" );
3571   createSMESHAction(  806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3572   createSMESHAction(  801, "CREATE_GROUP",    "ICON_CREATE_GROUP" );
3573   createSMESHAction(  802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3574   createSMESHAction(  803, "EDIT_GROUP",      "ICON_EDIT_GROUP" );
3575   createSMESHAction(  815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3576   createSMESHAction(  804, "ADD" );
3577   createSMESHAction(  805, "REMOVE" );
3578   createSMESHAction(  810, "UN_GROUP",        "ICON_UNION" );
3579   createSMESHAction(  811, "INT_GROUP",       "ICON_INTERSECT" );
3580   createSMESHAction(  812, "CUT_GROUP",       "ICON_CUT" );
3581   createSMESHAction(  814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3582   createSMESHAction(  813, "DEL_GROUP",       "ICON_DEL_GROUP" );
3583   createSMESHAction(  900, "ADV_INFO",        "ICON_ADV_INFO" );
3584   //createSMESHAction(  902, "STD_INFO",        "ICON_STD_INFO" );
3585   //createSMESHAction(  903, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3586   createSMESHAction(  904, "FIND_ELEM",       "ICON_FIND_ELEM" );
3587   createSMESHAction( 6001, "LENGTH",          "ICON_LENGTH",        0, true );
3588   createSMESHAction( 6002, "FREE_EDGE",       "ICON_FREE_EDGE",     0, true );
3589   createSMESHAction( 6021, "FREE_FACES",      "ICON_FREE_FACES",    0, true );
3590   createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D",  "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
3591   createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D",  "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
3592   createSMESHAction( 6024, "BARE_BORDER_VOLUME",     "ICON_BARE_BORDER_VOLUME",      0, true );
3593   createSMESHAction( 6025, "BARE_BORDER_FACE",       "ICON_BARE_BORDER_FACE",        0, true );
3594   createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3595   createSMESHAction( 6027, "OVER_CONSTRAINED_FACE",  "ICON_OVER_CONSTRAINED_FACE",   0, true );
3596   createSMESHAction( 6028, "EQUAL_NODE",      "ICON_EQUAL_NODE",    0, true );
3597   createSMESHAction( 6029, "EQUAL_EDGE",      "ICON_EQUAL_EDGE",    0, true );
3598   createSMESHAction( 6030, "EQUAL_FACE",      "ICON_EQUAL_FACE",    0, true );
3599   createSMESHAction( 6031, "EQUAL_VOLUME",    "ICON_EQUAL_VOLUME",  0, true );
3600   createSMESHAction( 6003, "FREE_BORDER",     "ICON_FREE_EDGE_2D",  0, true );
3601   createSMESHAction( 6004, "CONNECTION",      "ICON_CONNECTION",    0, true );
3602   createSMESHAction( 6005, "FREE_NODE",       "ICON_FREE_NODE",     0, true );
3603   createSMESHAction( 6011, "AREA",            "ICON_AREA",          0, true );
3604   createSMESHAction( 6012, "TAPER",           "ICON_TAPER",         0, true );
3605   createSMESHAction( 6013, "ASPECT",          "ICON_ASPECT",        0, true );
3606   createSMESHAction( 6014, "MIN_ANG",         "ICON_ANGLE",         0, true );
3607   createSMESHAction( 6015, "WARP",            "ICON_WARP",          0, true );
3608   createSMESHAction( 6016, "SKEW",            "ICON_SKEW",          0, true );
3609   createSMESHAction( 6017, "ASPECT_3D",       "ICON_ASPECT_3D",     0, true );
3610   createSMESHAction( 6018, "LENGTH_2D",       "ICON_LENGTH_2D",     0, true );
3611   createSMESHAction( 6019, "CONNECTION_2D",   "ICON_CONNECTION_2D", 0, true );
3612   createSMESHAction( 6009, "VOLUME_3D",       "ICON_VOLUME_3D",     0, true );
3613   createSMESHAction( 4000, "NODE",            "ICON_DLG_NODE" );
3614   createSMESHAction( 4009, "ELEM0D",          "ICON_DLG_ELEM0D" );
3615   createSMESHAction( 4008, "BALL",            "ICON_DLG_BALL" );
3616   createSMESHAction( 4010, "EDGE",            "ICON_DLG_EDGE" );
3617   createSMESHAction( 4021, "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3618   createSMESHAction( 4022, "QUAD",            "ICON_DLG_QUADRANGLE" );
3619   createSMESHAction( 4023, "POLYGON",         "ICON_DLG_POLYGON" );
3620   createSMESHAction( 4031, "TETRA",           "ICON_DLG_TETRAS" );
3621   createSMESHAction( 4032, "HEXA",            "ICON_DLG_HEXAS" );
3622   createSMESHAction( 4133, "PENTA",           "ICON_DLG_PENTA" );
3623   createSMESHAction( 4134, "PYRAMID",         "ICON_DLG_PYRAMID" );
3624   createSMESHAction( 4135, "OCTA",            "ICON_DLG_OCTA" );
3625   createSMESHAction( 4033, "POLYHEDRON",              "ICON_DLG_POLYHEDRON" );
3626   createSMESHAction( 4034, "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
3627   createSMESHAction( 4035, "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
3628   createSMESHAction( 4036, "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
3629   createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3630   createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3631   createSMESHAction( 4038, "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
3632   createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3633   createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3634   createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3635   createSMESHAction( 4041, "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
3636   createSMESHAction( 4042, "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
3637   createSMESHAction( 4044, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
3638   createSMESHAction( 4043, "CLEAR_MESH"    ,  "ICON_CLEAR_MESH" );
3639   createSMESHAction( 4051, "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
3640   createSMESHAction( 4052, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
3641   createSMESHAction( 4061, "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
3642   createSMESHAction( 4062, "ROT",             "ICON_DLG_MESH_ROTATION" );
3643   createSMESHAction( 4063, "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
3644   createSMESHAction( 4064, "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
3645   createSMESHAction( 4065, "MERGE",           "ICON_SMESH_MERGE_NODES" );
3646   createSMESHAction( 4066, "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
3647   createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3648   createSMESHAction( 4068, "SCALE",           "ICON_DLG_MESH_SCALE" );
3649   createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3650   createSMESHAction(  407, "INV",             "ICON_DLG_MESH_DIAGONAL" );
3651   createSMESHAction(  408, "UNION2",          "ICON_UNION2TRI" );
3652   createSMESHAction(  409, "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
3653   createSMESHAction(  410, "UNION",           "ICON_UNIONTRI" );
3654   createSMESHAction(  411, "CUT",             "ICON_CUTQUAD" );
3655   createSMESHAction(  412, "SMOOTH",          "ICON_DLG_SMOOTHING" );
3656   createSMESHAction(  413, "EXTRUSION",       "ICON_EXTRUSION" );
3657   createSMESHAction(  414, "REVOLUTION",      "ICON_REVOLUTION" );
3658   createSMESHAction(  415, "MAP",             "ICON_MAP" );
3659   createSMESHAction(  416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3660   createSMESHAction(  417, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
3661   createSMESHAction(  418, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
3662   createSMESHAction(  419, "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
3663   createSMESHAction(  420, "REORIENT_2D",     "ICON_REORIENT_2D" );
3664   createSMESHAction(  200, "RESET" );
3665   createSMESHAction(  201, "SCALAR_BAR_PROP" );
3666   createSMESHAction(  2021, "SAVE_DISTRIBUTION" );
3667   createSMESHAction(  2022, "SHOW_DISTRIBUTION","",0, true );
3668 #ifndef DISABLE_PLOT2DVIEWER
3669   createSMESHAction(  2023, "PLOT_DISTRIBUTION" );
3670 #endif
3671   createSMESHAction(  211, "WIRE",           "ICON_WIRE", 0, true );
3672   createSMESHAction(  212, "SHADE",          "ICON_SHADE", 0, true );
3673   createSMESHAction(  213, "SHRINK",         "ICON_SHRINK", 0, true );
3674   createSMESHAction(  214, "UPDATE",         "ICON_UPDATE" );
3675   createSMESHAction(  215, "NODES",          "ICON_POINTS", 0, true );
3676   createSMESHAction(  222, "BALLS",          "ICON_DLG_BALL", 0, true );
3677   createSMESHAction(  216, "ELEMS0D",        "ICON_DLG_ELEM0D", 0, true );
3678   createSMESHAction(  217, "EDGES",          "ICON_DLG_EDGE", 0, true );
3679   createSMESHAction(  218, "FACES",          "ICON_DLG_TRIANGLE", 0, true );
3680   createSMESHAction(  219, "VOLUMES",        "ICON_DLG_TETRAS", 0, true );
3681   createSMESHAction(  220, "ALL" );
3682   createSMESHAction(  221, "FACE_ORIENTATION", "", 0, true );
3683
3684   createSMESHAction(  231, "LINE_REPRESENTATION", "", 0, true );
3685   createSMESHAction(  232, "ARC_REPRESENTATION", "", 0, true );
3686
3687   createSMESHAction( 1100, "EDIT_HYPO" );
3688   createSMESHAction( 1102, "UNASSIGN" );
3689   createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3690   createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3691   createSMESHAction( 1131, "DISPMODE" );
3692   createSMESHAction( 1132, "COLORS" );
3693   createSMESHAction( 1133, "TRANSP" );
3694   createSMESHAction( 1134, "CLIP" );
3695   createSMESHAction( 1135, "DISP_ENT" );
3696   createSMESHAction( 1136, "AUTO_COLOR" );
3697   createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3698   createSMESHAction( 2000, "CTRL" );
3699
3700   createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3701   createSMESHAction( 502, "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
3702
3703   createSMESHAction( 300, "HIDE" );
3704   createSMESHAction( 301, "SHOW" );
3705   createSMESHAction( 302, "DISPLAY_ONLY" );
3706
3707   // ----- create menu --------------
3708   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
3709       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
3710       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
3711       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
3712       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
3713       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
3714       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3715       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
3716
3717   createMenu( separator(), fileId );
3718
3719   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3720       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3721       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3722       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3723       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3724       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3725       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
3726       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3727       renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
3728       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3729
3730   //createMenu( 111, importId, -1 );
3731   createMenu( 112, importId, -1 );
3732   createMenu( 113, importId, -1 );
3733   createMenu( 115, importId, -1 );
3734 #ifdef WITH_CGNS
3735   createMenu( 116, importId, -1 );
3736 #endif
3737   createMenu( 117, importId, -1 );
3738   createMenu( 118, importId, -1 );
3739   createMenu( 121, exportId, -1 );
3740   createMenu( 122, exportId, -1 );
3741   createMenu( 123, exportId, -1 );
3742   createMenu( 140, exportId, -1 ); // export to STL
3743 #ifdef WITH_CGNS
3744   createMenu( 142, exportId, -1 ); // export to CGNS
3745 #endif
3746   createMenu( 144, exportId, -1 ); // export to SAUV
3747   createMenu( 146, exportId, -1 ); // export to GMF
3748   createMenu( separator(), fileId, 10 );
3749
3750   createMenu( 33, editId, -1 );
3751
3752   createMenu( 5105, toolsId, -1 );
3753
3754   createMenu( 702, meshId, -1 ); // "Mesh" menu
3755   createMenu( 703, meshId, -1 );
3756   createMenu( 704, meshId, -1 );
3757   createMenu( 710, meshId, -1 );
3758   createMenu( 705, meshId, -1 );
3759   createMenu( separator(), meshId, -1 );
3760   createMenu( 701, meshId, -1 );
3761   createMenu( 711, meshId, -1 );
3762   createMenu( 712, meshId, -1 );
3763   createMenu( 713, meshId, -1 );
3764   createMenu( separator(), meshId, -1 );
3765   createMenu( 801, meshId, -1 );
3766   createMenu( 806, meshId, -1 );
3767   createMenu( 802, meshId, -1 );
3768   createMenu( 803, meshId, -1 );
3769   createMenu( 815, meshId, -1 );
3770   createMenu( separator(), meshId, -1 );
3771   createMenu( 810, meshId, -1 );
3772   createMenu( 811, meshId, -1 );
3773   createMenu( 812, meshId, -1 );
3774   createMenu( separator(), meshId, -1 );
3775   createMenu( 814, meshId, -1 );
3776   createMenu( separator(), meshId, -1 );
3777   createMenu( 900, meshId, -1 );
3778   //createMenu( 902, meshId, -1 );
3779   //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3780   createMenu( 904, meshId, -1 );
3781   createMenu( separator(), meshId, -1 );
3782
3783   createMenu( 6005, nodeId, -1 );
3784   createMenu( 6028, nodeId, -1 );
3785   createMenu( 6002, edgeId, -1 );
3786   createMenu( 6003, edgeId, -1 );
3787   createMenu( 6001, edgeId, -1 );
3788   createMenu( 6004, edgeId, -1 );
3789   createMenu( 6029, edgeId, -1 );
3790   createMenu( 6021, faceId, -1 );
3791   createMenu( 6025, faceId, -1 );
3792   createMenu( 6027, faceId, -1 );
3793   createMenu( 6018, faceId, -1 );
3794   createMenu( 6019, faceId, -1 );
3795   createMenu( 6011, faceId, -1 );
3796   createMenu( 6012, faceId, -1 );
3797   createMenu( 6013, faceId, -1 );
3798   createMenu( 6014, faceId, -1 );
3799   createMenu( 6015, faceId, -1 );
3800   createMenu( 6016, faceId, -1 );
3801   createMenu( 6022, faceId, -1 );
3802   createMenu( 6030, faceId, -1 );
3803   createMenu( 6017, volumeId, -1 );
3804   createMenu( 6009, volumeId, -1 );
3805   createMenu( 6023, volumeId, -1 );
3806   createMenu( 6024, volumeId, -1 );
3807   createMenu( 6026, volumeId, -1 );
3808   createMenu( 6031, volumeId, -1 );
3809
3810   createMenu( 4000, addId, -1 );
3811   createMenu( 4009, addId, -1 );
3812   createMenu( 4008, addId, -1 );
3813   createMenu( 4010, addId, -1 );
3814   createMenu( 4021, addId, -1 );
3815   createMenu( 4022, addId, -1 );
3816   createMenu( 4023, addId, -1 );
3817   createMenu( 4031, addId, -1 );
3818   createMenu( 4032, addId, -1 );
3819   createMenu( 4133, addId, -1 );
3820   createMenu( 4134, addId, -1 );
3821   createMenu( 4135, addId, -1 );
3822   createMenu( 4033, addId, -1 );
3823   createMenu( separator(), addId, -1 );
3824   createMenu( 4034, addId, -1 );
3825   createMenu( 4035, addId, -1 );
3826   createMenu( 4036, addId, -1 );
3827   createMenu( 4136, addId, -1 );
3828   createMenu( 4037, addId, -1 );
3829   createMenu( 4038, addId, -1 );
3830   createMenu( 4039, addId, -1 );
3831   createMenu( 4040, addId, -1 );
3832   createMenu( 4140, addId, -1 );
3833
3834   createMenu( 4041, removeId, -1 );
3835   createMenu( 4042, removeId, -1 );
3836   createMenu( 4044, removeId, -1 );
3837   createMenu( separator(), removeId, -1 );
3838   createMenu( 813, removeId, -1 );
3839   createMenu( separator(), removeId, -1 );
3840   createMenu( 4043, removeId, -1 );
3841
3842   createMenu( 4051, renumId, -1 );
3843   createMenu( 4052, renumId, -1 );
3844
3845   createMenu( 4061, transfId, -1 );
3846   createMenu( 4062, transfId, -1 );
3847   createMenu( 4063, transfId, -1 );
3848   createMenu( 4068, transfId, -1 );
3849   createMenu( 4064, transfId, -1 );
3850   createMenu( 4065, transfId, -1 );
3851   createMenu( 4066, transfId, -1 );
3852   createMenu( 4069, transfId, -1 );
3853
3854   createMenu( 4067,modifyId, -1 );
3855   createMenu( 407, modifyId, -1 );
3856   createMenu( 408, modifyId, -1 );
3857   createMenu( 409, modifyId, -1 );
3858   createMenu( 420, modifyId, -1 );
3859   createMenu( 410, modifyId, -1 );
3860   createMenu( 411, modifyId, -1 );
3861   createMenu( 419, modifyId, -1 );
3862   createMenu( 412, modifyId, -1 );
3863   createMenu( 413, modifyId, -1 );
3864   createMenu( 416, modifyId, -1 );
3865   createMenu( 414, modifyId, -1 );
3866   createMenu( 415, modifyId, -1 );
3867   createMenu( 417, modifyId, -1 );
3868   createMenu( 418, modifyId, -1 );
3869
3870   createMenu( 501, measureId, -1 );
3871   createMenu( 502, measureId, -1 );
3872   createMenu( 214, viewId, -1 );
3873
3874   // ----- create toolbars --------------
3875   int meshTb     = createTool( tr( "TB_MESH" ) ),
3876       ctrlTb     = createTool( tr( "TB_CTRL" ) ),
3877       addRemTb   = createTool( tr( "TB_ADD_REMOVE" ) ),
3878       modifyTb   = createTool( tr( "TB_MODIFY" ) ),
3879       dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3880
3881   createTool( 702, meshTb );
3882   createTool( 703, meshTb );
3883   createTool( 704, meshTb );
3884   createTool( 710, meshTb );
3885   createTool( 705, meshTb );
3886   createTool( separator(), meshTb );
3887   createTool( 701, meshTb );
3888   createTool( 711, meshTb );
3889   createTool( 712, meshTb );
3890   createTool( 713, meshTb );
3891   createTool( separator(), meshTb );
3892   createTool( 801, meshTb );
3893   createTool( 806, meshTb );
3894   createTool( 802, meshTb );
3895   createTool( 803, meshTb );
3896   //createTool( 815, meshTb );
3897   createTool( separator(), meshTb );
3898   createTool( 900, meshTb );
3899   //createTool( 902, meshTb );
3900   //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3901   createTool( 904, meshTb );
3902   createTool( separator(), meshTb );
3903
3904   createTool( 6005, ctrlTb );
3905   createTool( 6028, ctrlTb );
3906   createTool( separator(), ctrlTb );
3907   createTool( 6002, ctrlTb );
3908   createTool( 6003, ctrlTb );
3909   createTool( 6001, ctrlTb );
3910   createTool( 6004, ctrlTb );
3911   createTool( 6029, ctrlTb );
3912   createTool( separator(), ctrlTb );
3913   createTool( 6021, ctrlTb );
3914   createTool( 6025, ctrlTb );
3915   createTool( 6027, ctrlTb );
3916   createTool( 6018, ctrlTb );
3917   createTool( 6019, ctrlTb );
3918   createTool( 6011, ctrlTb );
3919   createTool( 6012, ctrlTb );
3920   createTool( 6013, ctrlTb );
3921   createTool( 6014, ctrlTb );
3922   createTool( 6015, ctrlTb );
3923   createTool( 6016, ctrlTb );
3924   createTool( 6022, ctrlTb );
3925   createTool( 6030, ctrlTb );
3926   createTool( separator(), ctrlTb );
3927   createTool( 6017, ctrlTb );
3928   createTool( 6009, ctrlTb );
3929   createTool( 6023, ctrlTb );
3930   createTool( 6024, ctrlTb );
3931   createTool( 6026, ctrlTb );
3932   createTool( 6031, ctrlTb );
3933   createTool( separator(), ctrlTb );
3934
3935   createTool( 4000, addRemTb );
3936   createTool( 4009, addRemTb );
3937   createTool( 4008, addRemTb );
3938   createTool( 4010, addRemTb );
3939   createTool( 4021, addRemTb );
3940   createTool( 4022, addRemTb );
3941   createTool( 4023, addRemTb );
3942   createTool( 4031, addRemTb );
3943   createTool( 4032, addRemTb );
3944   createTool( 4133, addRemTb );
3945   createTool( 4134, addRemTb );
3946   createTool( 4135, addRemTb );
3947   createTool( 4033, addRemTb );
3948   createTool( separator(), addRemTb );
3949   createTool( 4034, addRemTb );
3950   createTool( 4035, addRemTb );
3951   createTool( 4036, addRemTb );
3952   createTool( 4136, addRemTb );
3953   createTool( 4037, addRemTb );
3954   createTool( 4038, addRemTb );
3955   createTool( 4039, addRemTb );
3956   createTool( 4040, addRemTb );
3957   createTool( 4140, addRemTb );
3958   createTool( separator(), addRemTb );
3959   createTool( 4041, addRemTb );
3960   createTool( 4042, addRemTb );
3961   createTool( 4044, addRemTb );
3962   createTool( 4043, addRemTb );
3963   createTool( separator(), addRemTb );
3964   createTool( 4051, addRemTb );
3965   createTool( 4052, addRemTb );
3966   createTool( separator(), addRemTb );
3967   createTool( 4061, addRemTb );
3968   createTool( 4062, addRemTb );
3969   createTool( 4063, addRemTb );
3970   createTool( 4068, addRemTb );
3971   createTool( 4064, addRemTb );
3972   createTool( 4065, addRemTb );
3973   createTool( 4066, addRemTb );
3974   createTool( 4069, addRemTb );
3975   createTool( separator(), addRemTb );
3976
3977   createTool( 4067,modifyTb );
3978   createTool( 407, modifyTb );
3979   createTool( 408, modifyTb );
3980   createTool( 409, modifyTb );
3981   createTool( 420, modifyTb );
3982   createTool( 410, modifyTb );
3983   createTool( 411, modifyTb );
3984   createTool( 419, modifyTb );
3985   createTool( 412, modifyTb );
3986   createTool( 413, modifyTb );
3987   createTool( 416, modifyTb );
3988   createTool( 414, modifyTb );
3989   createTool( 415, modifyTb );
3990   createTool( 417, modifyTb );
3991   createTool( 418, modifyTb );
3992
3993   createTool( 214, dispModeTb );
3994
3995   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3996   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3997
3998   myRules.clear();
3999   QString OB = "'ObjectBrowser'",
4000           View = "'" + SVTK_Viewer::Type() + "'",
4001           pat = "'%1'",
4002           mesh    = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
4003           group   = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
4004           hypo    = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
4005           algo    = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
4006           elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4007                        arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
4008                        arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
4009                        arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
4010                        arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
4011                        arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
4012                        arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
4013           subMesh = elems,
4014           mesh_part = mesh + " " + subMesh + " " + group,
4015           mesh_group = mesh + " " + group,
4016           hyp_alg = hypo + " " + algo;
4017
4018   // popup for object browser
4019   QString
4020     isInvisible("not( isVisible )"),
4021     isEmpty("numberOfNodes = 0"),
4022     isNotEmpty("numberOfNodes <> 0"),
4023
4024     // has nodes, edges, etc in VISIBLE! actor
4025     hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4026     hasElems("(count( elemTypes ) > 0)"),
4027     hasDifferentElems("(count( elemTypes ) > 1)"),
4028     hasBalls("({'BallElem'} in elemTypes)"),
4029     hasElems0d("({'Elem0d'} in elemTypes)"),
4030     hasEdges("({'Edge'} in elemTypes)"),
4031     hasFaces("({'Face'} in elemTypes)"),
4032     hasVolumes("({'Volume'} in elemTypes)");
4033
4034   createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" );      // FILE INFORMATION
4035   createPopupItem( 703, OB, mesh, "&& isComputable");      // CREATE_SUBMESH
4036   createPopupItem( 704, OB, mesh, "&& isComputable");      // EDIT_MESHSUBMESH
4037   createPopupItem( 704, OB, subMesh, "&& isComputable" );  // EDIT_MESHSUBMESH
4038   createPopupItem( 803, OB, group );                       // EDIT_GROUP
4039   createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4040
4041   popupMgr()->insert( separator(), -1, 0 );
4042   createPopupItem( 701, OB, mesh, "&& isComputable" );     // COMPUTE
4043   createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4044   createPopupItem( 712, OB, mesh, "&& isComputable" );     // EVALUATE
4045   createPopupItem( 713, OB, mesh, "&& isComputable" );     // MESH ORDER
4046   createPopupItem( 214, OB, mesh_part );                   // UPDATE
4047   createPopupItem( 900, OB, mesh_part );                   // ADV_INFO
4048   createPopupItem( 904, OB, mesh_group );                  // FIND_ELEM
4049   popupMgr()->insert( separator(), -1, 0 );
4050   createPopupItem( 801, OB, mesh );                        // CREATE_GROUP
4051   createPopupItem( 806, OB, mesh );                        // CREATE_GEO_GROUP
4052   createPopupItem( 802, OB, subMesh );                     // CONSTRUCT_GROUP
4053   popupMgr()->insert( separator(), -1, 0 );
4054   createPopupItem( 1100, OB, hypo);                        // EDIT HYPOTHESIS
4055   createPopupItem( 1102, OB, hyp_alg );                    // REMOVE HYPOTHESIS / ALGORITHMS
4056   popupMgr()->insert( separator(), -1, 0 );
4057   createPopupItem( 4043, OB, mesh );                       // CLEAR_MESH
4058   popupMgr()->insert( separator(), -1, 0 );
4059   createPopupItem( 417, OB, mesh + " " + subMesh );        // convert to quadratic
4060   createPopupItem( 418, OB, mesh + " " + group,            // create 2D mesh from 3D
4061                    "&& dim>=2");
4062   popupMgr()->insert( separator(), -1, 0 );
4063
4064   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4065   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4066   QString only_one_2D        = only_one_non_empty + " && dim>1";
4067
4068   createPopupItem( 125, OB, mesh_group, multiple_non_empty );   // EXPORT_MED
4069   createPopupItem( 126, OB, mesh_group, only_one_non_empty );   // EXPORT_UNV
4070   createPopupItem( 141, OB, mesh_group, only_one_2D );          // EXPORT_STL
4071 #ifdef WITH_CGNS
4072   createPopupItem( 143, OB, mesh_group, multiple_non_empty );   // EXPORT_CGNS
4073 #endif
4074   createPopupItem( 145, OB, mesh_group, multiple_non_empty );   // EXPORT_SAUV
4075   createPopupItem(  33, OB, mesh_part + " " + hyp_alg );        // DELETE
4076   createPopupItem( 813, OB, group );                            // DEL_GROUP with contents
4077   popupMgr()->insert( separator(), -1, 0 );
4078
4079   // popup for viewer
4080   createPopupItem( 803, View, group ); // EDIT_GROUP
4081   createPopupItem( 804, View, elems ); // ADD
4082   createPopupItem( 805, View, elems ); // REMOVE
4083
4084   popupMgr()->insert( separator(), -1, 0 );
4085   createPopupItem( 214, View, mesh_part );  // UPDATE
4086   createPopupItem( 900, View, mesh_part );  // ADV_INFO
4087   createPopupItem( 904, View, mesh );       // FIND_ELEM
4088   popupMgr()->insert( separator(), -1, 0 );
4089
4090   createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4091   createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" );       // DISABLE_AUTO_COLOR
4092   popupMgr()->insert( separator(), -1, 0 );
4093
4094   int anId;
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",  0 );
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   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5230   if (!appStudy || !appStudy->studyDS())
5231     return;
5232   _PTR(Study) studyDS = appStudy->studyDS();
5233
5234   // componentName is used for encoding of entries when storing them in IParameters
5235   std::string componentName = myComponentSMESH->ComponentDataType();
5236   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5237   //if (!aSComponent) return;
5238
5239   // IParameters
5240   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5241                                                              componentName.c_str(),
5242                                                              savePoint);
5243   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5244
5245   // store map of custom markers
5246   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5247   if( !aMarkerMap.empty() )
5248   {
5249     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5250     for( ; anIter != aMarkerMap.end(); anIter++ )
5251     {
5252       int anId = anIter->first;
5253       VTK::MarkerData aMarkerData = anIter->second;
5254       std::string aMarkerFileName = aMarkerData.first;
5255       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5256       if( aMarkerTexture.size() < 3 )
5257         continue; // should contain at least width, height and the first value
5258
5259       QString aPropertyName( "texture" );
5260       aPropertyName += gSeparator;
5261       aPropertyName += QString::number( anId );
5262
5263       QString aPropertyValue = aMarkerFileName.c_str();
5264       aPropertyValue += gPathSep;
5265
5266       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5267       ushort aWidth = *aTextureIter++;
5268       ushort aHeight = *aTextureIter++;
5269       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5270       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5271       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5272         aPropertyValue += QString::number( *aTextureIter );
5273
5274       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5275     }
5276   }
5277
5278   // viewers counters are used for storing view_numbers in IParameters
5279   int vtkViewers = 0;
5280
5281   // main cycle to store parameters of displayed objects
5282   QList<SUIT_ViewManager*> lst;
5283   QList<SUIT_ViewManager*>::Iterator it;
5284   getApp()->viewManagers(lst);
5285   for (it = lst.begin(); it != lst.end(); it++)
5286   {
5287     SUIT_ViewManager* vman = *it;
5288     QString vType = vman->getType();
5289
5290     // saving VTK actors properties
5291     if (vType == SVTK_Viewer::Type())
5292     {
5293       // store the clipping planes attached to the view manager
5294       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5295       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5296       if( anIter != myClippingPlaneInfoMap.end() )
5297         aClippingPlaneInfoList = anIter->second;
5298
5299       if( !aClippingPlaneInfoList.empty() ) {
5300         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5301         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5302         {
5303           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5304           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5305
5306           QString aPropertyName( "ClippingPlane" );
5307           aPropertyName += gSeparator;
5308           aPropertyName += QString::number( vtkViewers );
5309           aPropertyName += gSeparator;
5310           aPropertyName += QString::number( anId );
5311
5312           QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5313           aPropertyValue += gDigitsSep;
5314           aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5315           aPropertyValue += gDigitsSep;
5316           aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5317           aPropertyValue += gDigitsSep;
5318           aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5319
5320           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5321         }
5322       }
5323
5324       QVector<SUIT_ViewWindow*> views = vman->getViews();
5325       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5326       {
5327         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5328         {
5329           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5330           vtkActorCollection* allActors = aCopy.GetActors();
5331           allActors->InitTraversal();
5332           while (vtkActor* actor = allActors->GetNextActor())
5333           {
5334             if (actor->GetVisibility()) // store only visible actors
5335             {
5336               SMESH_Actor* aSmeshActor = 0;
5337               if (actor->IsA("SMESH_Actor"))
5338                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5339               if (aSmeshActor && aSmeshActor->hasIO())
5340               {
5341                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5342                 if (io->hasEntry())
5343                 {
5344                   // entry is "encoded" = it does NOT contain component adress,
5345                   // since it is a subject to change on next component loading
5346                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5347
5348                   std::string param, vtkParam = vType.toLatin1().data();
5349                   vtkParam += gSeparator;
5350                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5351                   vtkParam += gSeparator;
5352
5353                   // Visibility
5354                   param = vtkParam + "Visibility";
5355                   ip->setParameter(entry, param, "On");
5356
5357                   // Representation
5358                   param = vtkParam + "Representation";
5359                   ip->setParameter(entry, param, QString::number
5360                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5361
5362                   // IsShrunk
5363                   param = vtkParam + "IsShrunk";
5364                   ip->setParameter(entry, param, QString::number
5365                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5366
5367                   // Displayed entities
5368                   unsigned int aMode = aSmeshActor->GetEntityMode();
5369                   bool isE = aMode & SMESH_Actor::eEdges;
5370                   bool isF = aMode & SMESH_Actor::eFaces;
5371                   bool isV = aMode & SMESH_Actor::eVolumes;
5372
5373                   QString modeStr ("e");
5374                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5375                   modeStr += gDigitsSep; modeStr += "f";
5376                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5377                   modeStr += gDigitsSep; modeStr += "v";
5378                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5379
5380                   param = vtkParam + "Entities";
5381                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5382
5383                   // Colors (surface:edge:)
5384                   vtkFloatingPointType r, g, b;
5385                   int delta;
5386
5387                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5388                   QString colorStr ("surface");
5389                   colorStr += gDigitsSep; colorStr += QString::number(r);
5390                   colorStr += gDigitsSep; colorStr += QString::number(g);
5391                   colorStr += gDigitsSep; colorStr += QString::number(b);
5392
5393                   colorStr += gDigitsSep; colorStr += "backsurface";
5394                   colorStr += gDigitsSep; colorStr += QString::number(delta);
5395
5396
5397                   aSmeshActor->GetEdgeColor(r, g, b);
5398                   colorStr += gDigitsSep; colorStr += "edge";
5399                   colorStr += gDigitsSep; colorStr += QString::number(r);
5400                   colorStr += gDigitsSep; colorStr += QString::number(g);
5401                   colorStr += gDigitsSep; colorStr += QString::number(b);
5402
5403                   aSmeshActor->GetNodeColor(r, g, b);
5404                   colorStr += gDigitsSep; colorStr += "node";
5405                   colorStr += gDigitsSep; colorStr += QString::number(r);
5406                   colorStr += gDigitsSep; colorStr += QString::number(g);
5407                   colorStr += gDigitsSep; colorStr += QString::number(b);
5408
5409                   aSmeshActor->GetOutlineColor(r, g, b);
5410                   colorStr += gDigitsSep; colorStr += "outline";
5411                   colorStr += gDigitsSep; colorStr += QString::number(r);
5412                   colorStr += gDigitsSep; colorStr += QString::number(g);
5413                   colorStr += gDigitsSep; colorStr += QString::number(b);
5414
5415                   param = vtkParam + "Colors";
5416                   ip->setParameter(entry, param, colorStr.toLatin1().data());
5417
5418                   // Sizes of lines and points
5419                   QString sizeStr ("line");
5420                   sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5421                   sizeStr += gDigitsSep; sizeStr += "shrink";
5422                   sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5423
5424                   param = vtkParam + "Sizes";
5425                   ip->setParameter(entry, param, sizeStr.toLatin1().data());
5426
5427                   // Point marker
5428                   QString markerStr;
5429
5430                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5431                   if( aMarkerType == VTK::MT_USER ) {
5432                     markerStr += "custom";
5433                     markerStr += gDigitsSep;
5434                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5435                   }
5436                   else {
5437                     markerStr += "std";
5438                     markerStr += gDigitsSep;
5439                     markerStr += QString::number( (int)aMarkerType );
5440                     markerStr += gDigitsSep;
5441                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5442                   }
5443
5444                   param = vtkParam + "PointMarker";
5445                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5446
5447                   // Opacity
5448                   param = vtkParam + "Opacity";
5449                   ip->setParameter(entry, param,
5450                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5451
5452                   // Clipping
5453                   param = vtkParam + "ClippingPlane";
5454                   int aPlaneId = 0;
5455                   if( !aClippingPlaneInfoList.empty() ) {
5456                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5457                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5458                     {
5459                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5460                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5461                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5462                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5463                         if( aSmeshActor == *anIter2 ) {
5464                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5465                                             QString::number( anId ).toLatin1().constData() );
5466                           break;
5467                         }
5468                       }
5469                     }
5470                   }
5471                   if( aPlaneId == 0 )
5472                     ip->setParameter( entry, param, "Off" );
5473                 } // if (io->hasEntry())
5474               } // SMESH_Actor && hasIO
5475             } // isVisible
5476           } // while.. actors traversal
5477         } // if (vtkView)
5478       } // for (views)
5479       vtkViewers++;
5480     } // if (SVTK view model)
5481   } // for (viewManagers)
5482 }
5483
5484 // data structures for clipping planes processing
5485 typedef struct {
5486   int Id;
5487   vtkIdType Orientation;
5488   vtkFloatingPointType Distance;
5489   vtkFloatingPointType Angle[2];
5490 } TPlaneData;
5491 typedef std::list<TPlaneData>         TPlaneDataList;
5492 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5493
5494 typedef std::list<vtkActor*>          TActorList;
5495 typedef struct {
5496   int PlaneId;
5497   TActorList ActorList;
5498   SUIT_ViewManager* ViewManager;
5499 } TPlaneInfo;
5500 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5501 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5502
5503 /*!
5504  * \brief Restore visual parameters
5505  *
5506  * This method is called after the study document is opened.
5507  * Restore visual parameters from AttributeParameter attribue(s)
5508  */
5509 void SMESHGUI::restoreVisualParameters (int savePoint)
5510 {
5511   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5512   if (!appStudy || !appStudy->studyDS())
5513     return;
5514   _PTR(Study) studyDS = appStudy->studyDS();
5515
5516   // componentName is used for encoding of entries when storing them in IParameters
5517   std::string componentName = myComponentSMESH->ComponentDataType();
5518   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5519   //if (!aSComponent) return;
5520
5521   // IParameters
5522   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5523                                                              componentName.c_str(),
5524                                                              savePoint);
5525   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5526
5527   // restore map of custom markers and map of clipping planes
5528   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5529   TPlaneDataMap aPlaneDataMap;
5530
5531   std::vector<std::string> properties = ip->getProperties();
5532   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5533   {
5534     std::string property = *propIt;
5535     QString aPropertyName( property.c_str() );
5536     QString aPropertyValue( ip->getProperty( property ).c_str() );
5537
5538     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5539     if( aPropertyNameList.isEmpty() )
5540       continue;
5541
5542     QString aPropertyType = aPropertyNameList[0];
5543     if( aPropertyType == "texture" )
5544     {
5545       if( aPropertyNameList.size() != 2 )
5546         continue;
5547
5548       bool ok = false;
5549       int anId = aPropertyNameList[1].toInt( &ok );
5550       if( !ok || anId < 1 )
5551         continue;
5552
5553       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5554       if( aPropertyValueList.size() != 2 )
5555         continue;
5556
5557       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5558       QString aMarkerTextureString = aPropertyValueList[1];
5559       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5560       if( aMarkerTextureStringList.size() != 3 )
5561         continue;
5562
5563       ok = false;
5564       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5565       if( !ok )
5566         continue;
5567
5568       ok = false;
5569       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5570       if( !ok )
5571         continue;
5572
5573       VTK::MarkerTexture aMarkerTexture;
5574       aMarkerTexture.push_back( aWidth );
5575       aMarkerTexture.push_back( aHeight );
5576
5577       QString aMarkerTextureData = aMarkerTextureStringList[2];
5578       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5579       {
5580         QChar aChar = aMarkerTextureData.at( i );
5581         if( aChar.isDigit() )
5582           aMarkerTexture.push_back( aChar.digitValue() );
5583       }
5584
5585       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5586     }
5587     else if( aPropertyType == "ClippingPlane" )
5588     {
5589       if( aPropertyNameList.size() != 3 )
5590         continue;
5591
5592       bool ok = false;
5593       int aViewId = aPropertyNameList[1].toInt( &ok );
5594       if( !ok || aViewId < 0 )
5595         continue;
5596
5597       ok = false;
5598       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5599       if( !ok || aClippingPlaneId < 0 )
5600         continue;
5601
5602       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5603       if( aPropertyValueList.size() != 4 )
5604         continue;
5605
5606       TPlaneData aPlaneData;
5607       aPlaneData.Id = aClippingPlaneId;
5608
5609       ok = false;
5610       aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5611       if( !ok )
5612         continue;
5613
5614       ok = false;
5615       aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5616       if( !ok )
5617         continue;
5618
5619       ok = false;
5620       aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5621       if( !ok )
5622         continue;
5623
5624       ok = false;
5625       aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5626       if( !ok )
5627         continue;
5628
5629       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5630       aPlaneDataList.push_back( aPlaneData );
5631     }
5632   }
5633
5634   TPlaneInfoMap aPlaneInfoMap;
5635
5636   std::vector<std::string> entries = ip->getEntries();
5637
5638   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5639   {
5640     // entry is a normal entry - it should be "decoded" (setting base adress of component)
5641     QString entry (ip->decodeEntry(*entIt).c_str());
5642
5643     // Check that the entry corresponds to a real object in the Study
5644     // as the object may be deleted or modified after the visual state is saved.
5645     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5646     if (!so) continue; //Skip the not existent entry
5647
5648     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5649     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5650
5651     std::vector<std::string>::iterator namesIt = paramNames.begin();
5652     std::vector<std::string>::iterator valuesIt = paramValues.begin();
5653
5654     // actors are stored in a map after displaying of them for
5655     // quicker access in the future: map < viewID to actor >
5656     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5657
5658     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5659     {
5660       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5661       // '_' is used as separator and should not be used in viewer type or parameter names.
5662       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5663       if (lst.size() != 3)
5664         continue;
5665
5666       QString viewerTypStr = lst[0];
5667       QString viewIndexStr = lst[1];
5668       QString paramNameStr = lst[2];
5669
5670       bool ok;
5671       int viewIndex = viewIndexStr.toUInt(&ok);
5672       if (!ok) // bad conversion of view index to integer
5673         continue;
5674
5675       // viewers
5676       if (viewerTypStr == SVTK_Viewer::Type())
5677       {
5678         SMESH_Actor* aSmeshActor = 0;
5679         if (vtkActors.IsBound(viewIndex))
5680           aSmeshActor = vtkActors.Find(viewIndex);
5681
5682         QList<SUIT_ViewManager*> lst;
5683         getApp()->viewManagers(viewerTypStr, lst);
5684
5685         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5686         SUIT_ViewManager* vman = NULL;
5687         if (viewIndex >= 0 && viewIndex < lst.count())
5688           vman = lst.at(viewIndex);
5689
5690         if (paramNameStr == "Visibility")
5691         {
5692           if (!aSmeshActor && displayer() && vman)
5693           {
5694             SUIT_ViewModel* vmodel = vman->getViewModel();
5695             // SVTK view model can be casted to SALOME_View
5696             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5697
5698             // store displayed actor in a temporary map for quicker
5699             // access later when restoring other parameters
5700             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5701             vtkRenderer* Renderer = vtkView->getRenderer();
5702             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5703             vtkActorCollection* theActors = aCopy.GetActors();
5704             theActors->InitTraversal();
5705             bool isFound = false;
5706             vtkActor *ac = theActors->GetNextActor();
5707             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5708               if (ac->IsA("SMESH_Actor")) {
5709                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5710                 if (aGeomAc->hasIO()) {
5711                   Handle(SALOME_InteractiveObject) io =
5712                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5713                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5714                     isFound = true;
5715                     vtkActors.Bind(viewIndex, aGeomAc);
5716                   }
5717                 }
5718               }
5719             }
5720           }
5721         } // if (paramNameStr == "Visibility")
5722         else
5723         {
5724           // the rest properties "work" with SMESH_Actor
5725           if (aSmeshActor)
5726           {
5727             QString val ((*valuesIt).c_str());
5728
5729             // Representation
5730             if (paramNameStr == "Representation") {
5731               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5732             }
5733             // IsShrunk
5734             else if (paramNameStr == "IsShrunk") {
5735               if (val.toInt()) {
5736                 if (!aSmeshActor->IsShrunk())
5737                   aSmeshActor->SetShrink();
5738               }
5739               else {
5740                 if (aSmeshActor->IsShrunk())
5741                   aSmeshActor->UnShrink();
5742               }
5743             }
5744             // Displayed entities
5745             else if (paramNameStr == "Entities") {
5746               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5747               if (mode.count() == 6) {
5748                 if (mode[0] != "e" || mode[2]  != "f" || mode[4] != "v") {
5749                   MESSAGE("Invalid order of data in Entities, must be: "
5750                           "e:0/1:f:0/1:v:0/1");
5751                 }
5752                 else {
5753                   unsigned int aMode = aSmeshActor->GetEntityMode();
5754                   unsigned int aNewMode =
5755                     (int(SMESH_Actor::eEdges  ) * mode[1].toInt()) |
5756                     (int(SMESH_Actor::eFaces  ) * mode[3].toInt()) |
5757                     (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5758                   if (aNewMode != aMode)
5759                     aSmeshActor->SetEntityMode(aNewMode);
5760                 }
5761               }
5762             }
5763             // Colors
5764             else if (paramNameStr == "Colors") {
5765               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5766               if (colors.count() == 16 || colors.count() == 18 ) {
5767                 if (colors[0] != "surface" || colors[4]  != "backsurface" ||
5768                     (colors[8] != "edge" && colors[6] != "edge" ) || (colors[12] != "node" && colors[10] != "node") ||
5769                     (colors.count() == 18 && colors[14] != "outline")) {
5770                   MESSAGE("Invalid order of data in Colors, must be: "
5771                           "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b or surface:r:g:b:backsurface:delta:edge:r:g:b:node:r:g:b:outline:r:g:b");
5772                 }
5773                 else {
5774                   int delta = 0;
5775                   float er,eg,eb;
5776                   float nr,ng,nb;
5777                   vtkFloatingPointType otr,otg,otb;
5778                   //Old case backsurface color is independent
5779                   if( colors.count() == 16 ) {
5780                     QColor ffc;
5781                     SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
5782                     er = colors[9].toFloat();
5783                     eg = colors[10].toFloat();
5784                     eb = colors[11].toFloat();
5785
5786                     nr = colors[13].toFloat();
5787                     ng = colors[14].toFloat();
5788                     nb = colors[15].toFloat();
5789                     SMESH::GetColor("SMESH", "outline_color", otr, otg, otb, QColor( 0, 70, 0 ) );
5790                   } else {
5791                     //New case backsurface color depends on surface color
5792                     delta = colors[5].toInt();
5793
5794                     er = colors[7].toFloat();
5795                     eg = colors[8].toFloat();
5796                     eb = colors[9].toFloat();
5797
5798                     nr = colors[11].toFloat();
5799                     ng = colors[12].toFloat();
5800                     nb = colors[13].toFloat();
5801
5802                     otr = colors[15].toFloat();
5803                     otg = colors[16].toFloat();
5804                     otb = colors[17].toFloat();
5805                   }
5806                   aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat(), delta);
5807                   aSmeshActor->SetEdgeColor(er,eg,eb);
5808                   aSmeshActor->SetNodeColor(nr,ng,nb);
5809                   aSmeshActor->SetOutlineColor(otr,otg,otb);
5810                 }
5811               }
5812             }
5813             // Sizes of lines and points
5814             else if (paramNameStr == "Sizes") {
5815               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5816               if (sizes.count() == 4) {
5817                 if (sizes[0] != "line" || sizes[2] != "shrink") {
5818                   MESSAGE("Invalid order of data in Sizes, must be: "
5819                           "line:int:shrink:float");
5820                 }
5821                 else {
5822                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5823                   aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5824                 }
5825               }
5826               else if (sizes.count() == 6) { // just to support old format
5827                 if (sizes[0] != "line" || sizes[2]  != "node" || sizes[4] != "shrink") {
5828                   MESSAGE("Invalid order of data in Sizes, must be: "
5829                           "line:int:node:int:shrink:float");
5830                 }
5831                 else {
5832                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5833                   //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5834                   aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5835                 }
5836               }
5837             }
5838             // Point marker
5839             else if (paramNameStr == "PointMarker") {
5840               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5841               if( data.count() >= 2 ) {
5842                 bool ok = false;
5843                 int aParam1 = data[1].toInt( &ok );
5844                 if( ok ) {
5845                   if( data[0] == "std" && data.count() == 3 ) {
5846                     int aParam2 = data[2].toInt( &ok );
5847                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5848                   }
5849                   else if( data[0] == "custom" ) {
5850                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5851                     if( markerIt != aMarkerMap.end() ) {
5852                       VTK::MarkerData aMarkerData = markerIt->second;
5853                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5854                     }
5855                   }
5856                 }
5857               }
5858             }
5859             // Opacity
5860             else if (paramNameStr == "Opacity") {
5861               aSmeshActor->SetOpacity(val.toFloat());
5862             }
5863             // Clipping
5864             else if (paramNameStr.startsWith("ClippingPlane")) {
5865               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5866               // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5867               // new format - val looks like "Off" or "0" (plane id)
5868               // (note: in new format "Off" value is used only for consistency,
5869               //  so it is processed together with values in old format)
5870               bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5871               if( anIsOldFormat ) {
5872                 if (paramNameStr == "ClippingPlane1" || val == "Off")
5873                   aSmeshActor->RemoveAllClippingPlanes();
5874                 if (val != "Off") {
5875                   SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5876                   double aDistance = vals[1].toFloat();
5877                   vtkFloatingPointType anAngle[2];
5878                   anAngle[0] = vals[2].toFloat();
5879                   anAngle[1] = vals[3].toFloat();
5880
5881                   QList<SUIT_ViewManager*> lst;
5882                   getApp()->viewManagers(viewerTypStr, lst);
5883                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5884                   if (viewIndex >= 0 && viewIndex < lst.count()) {
5885                     SUIT_ViewManager* vman = lst.at(viewIndex);
5886                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5887
5888                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5889
5890                     SMESH::TActorList anActorList;
5891                     anActorList.push_back( aSmeshActor );
5892                     SMESH::OrientedPlane* aPlane =
5893                       SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5894                     if( aPlane ) {
5895                       SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5896                       aClippingPlaneInfo.Plane = aPlane;
5897                       aClippingPlaneInfo.ActorList = anActorList;
5898                       aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5899                     }
5900                   }
5901                 }
5902               }
5903               else {
5904                 bool ok = false;
5905                 int aPlaneId = val.toInt( &ok );
5906                 if( ok && aPlaneId >= 0 ) {
5907                   bool anIsDefinedPlane = false;
5908                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5909                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5910                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5911                     TPlaneInfo& aPlaneInfo = *anIter;
5912                     if( aPlaneInfo.PlaneId == aPlaneId ) {
5913                       aPlaneInfo.ActorList.push_back( aSmeshActor );
5914                       anIsDefinedPlane = true;
5915                       break;
5916                     }
5917                   }
5918                   if( !anIsDefinedPlane ) {
5919                     TPlaneInfo aPlaneInfo;
5920                     aPlaneInfo.PlaneId = aPlaneId;
5921                     aPlaneInfo.ActorList.push_back( aSmeshActor );
5922                     aPlaneInfo.ViewManager = vman;
5923
5924                     // to make the list sorted by plane id
5925                     anIter = aPlaneInfoList.begin();
5926                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5927                       const TPlaneInfo& aPlaneInfoRef = *anIter;
5928                       if( aPlaneInfoRef.PlaneId > aPlaneId )
5929                         break;
5930                     }
5931                     aPlaneInfoList.insert( anIter, aPlaneInfo );
5932                   }
5933                 }
5934               }
5935             }
5936           } // if (aSmeshActor)
5937         } // other parameters than Visibility
5938       }
5939     } // for names/parameters iterator
5940   } // for entries iterator
5941
5942   // take into account planes with empty list of actors referred to them
5943   QList<SUIT_ViewManager*> aVMList;
5944   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5945
5946   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5947   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5948     int aViewId = aPlaneDataIter->first;
5949     if( aViewId >= 0 && aViewId < aVMList.count() ) {
5950       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5951
5952       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5953
5954       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5955       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5956       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5957         const TPlaneData& aPlaneData = *anIter2;
5958         int aPlaneId = aPlaneData.Id;
5959
5960         bool anIsFound = false;
5961         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5962         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5963           const TPlaneInfo& aPlaneInfo = *anIter3;
5964           if( aPlaneInfo.PlaneId == aPlaneId ) {
5965             anIsFound = true;
5966             break;
5967           }
5968         }
5969
5970         if( !anIsFound ) {
5971           TPlaneInfo aPlaneInfo; // ActorList field is empty
5972           aPlaneInfo.PlaneId = aPlaneId;
5973           aPlaneInfo.ViewManager = aViewManager;
5974
5975           // to make the list sorted by plane id
5976           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5977           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5978             const TPlaneInfo& aPlaneInfoRef = *anIter4;
5979             if( aPlaneInfoRef.PlaneId > aPlaneId )
5980               break;
5981           }
5982           aPlaneInfoList.insert( anIter4, aPlaneInfo );
5983         }
5984       }
5985     }
5986   }
5987
5988   // add clipping planes to actors according to the restored parameters
5989   // and update the clipping plane map
5990   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5991   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5992     int aViewId = anIter1->first;
5993     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5994
5995     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5996     if( anIter2 == aPlaneDataMap.end() )
5997       continue;
5998     const TPlaneDataList& aPlaneDataList = anIter2->second;
5999
6000     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6001     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6002       const TPlaneInfo& aPlaneInfo = *anIter3;
6003       int aPlaneId = aPlaneInfo.PlaneId;
6004       const TActorList& anActorList = aPlaneInfo.ActorList;
6005       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6006       if( !aViewManager )
6007         continue;
6008
6009       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6010       if( !aViewWindow )
6011         continue;
6012
6013       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6014
6015       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6016       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6017         const TPlaneData& aPlaneData = *anIter4;
6018         if( aPlaneData.Id == aPlaneId ) {
6019           SMESH::OrientedPlane* aPlane =
6020             SMESHGUI_ClippingDlg::AddPlane( anActorList,
6021                                             aViewWindow,
6022                                             (SMESH::Orientation)aPlaneData.Orientation,
6023                                             aPlaneData.Distance,
6024                                             aPlaneData.Angle );
6025           if( aPlane ) {
6026             SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6027             aClippingPlaneInfo.Plane = aPlane;
6028             aClippingPlaneInfo.ActorList = anActorList;
6029             aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6030           }
6031           break;
6032         }
6033       }
6034     }
6035   }
6036
6037   // update all VTK views
6038   QList<SUIT_ViewManager*> lst;
6039   getApp()->viewManagers(lst);
6040   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6041     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6042     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6043       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6044       vtkView->getRenderer()->ResetCameraClippingRange();
6045       vtkView->Repaint();
6046     }
6047   }
6048 }
6049
6050 /*!
6051   \brief Adds preferences for dfont of VTK viewer
6052   \param label label
6053   \param pIf group identifier
6054   \param param parameter
6055   \return identifier of preferences
6056 */
6057 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
6058 {
6059   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6060
6061   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6062
6063   QStringList fam;
6064   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6065   fam.append( tr( "SMESH_FONT_COURIER" ) );
6066   fam.append( tr( "SMESH_FONT_TIMES" ) );
6067
6068   setPreferenceProperty( tfont, "fonts", fam );
6069
6070   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6071   setPreferenceProperty( tfont, "features", f );
6072
6073   return tfont;
6074 }
6075
6076 /*!
6077   \brief Actions after hypothesis edition
6078   Updates object browser after hypothesis edition
6079 */
6080 void SMESHGUI::onHypothesisEdit( int result )
6081 {
6082   if( result == 1 )
6083     SMESHGUI::Modified();
6084   updateObjBrowser( true );
6085 }
6086
6087
6088 /*!
6089   \brief Signal handler closing(SUIT_ViewWindow*) of a view
6090   \param pview view being closed
6091 */
6092 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6093 #ifndef DISABLE_PLOT2DVIEWER
6094   //Crear all Plot2d Viewers if need.
6095   SMESH::ClearPlot2Viewers(pview);
6096 #endif
6097 }
6098
6099 void SMESHGUI::message( const QString& msg )
6100 {
6101   // dispatch message
6102   QStringList data = msg.split("/");
6103   if ( data.count() > 0 ) {
6104     if ( data.first() == "mesh_loading" ) {
6105       // get mesh entry
6106       QString entry = data.count() > 1 ? data[1] : QString();
6107       if ( entry.isEmpty() )
6108         return;
6109       // get study
6110       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6111       // get mesh name
6112       _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6113       QString name;
6114       if ( obj )
6115         name = obj->GetName().c_str();
6116       if ( name.isEmpty() )
6117         return;
6118
6119       if ( data.last() == "stop" )
6120         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6121       else
6122         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6123       QApplication::processEvents();
6124     }
6125   }
6126 }
6127
6128 /*!
6129   \brief Connects or disconnects signals about activating and cloning view on the module slots
6130   \param pview view which is connected/disconnected
6131 */
6132 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6133   if(!pview)
6134     return;
6135
6136   SUIT_ViewManager* viewMgr = pview->getViewManager();
6137   if ( viewMgr ) {
6138     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6139                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6140
6141     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6142              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6143   }
6144 }
6145
6146 /*!
6147   \brief Return \c true if object can be renamed
6148 */
6149 bool SMESHGUI::renameAllowed( const QString& entry) const {
6150   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6151   if( !anApp )
6152     return false;
6153
6154   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6155   if( !appStudy )
6156     return false;
6157
6158   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6159
6160   if(!obj)
6161     return false;
6162
6163   if(appStudy->isComponent(entry) || obj->isReference())
6164     return false;
6165
6166   // check type to prevent renaming of inappropriate objects
6167   int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6168   if (aType == MESH || aType == GROUP ||
6169       aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6170       aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6171       aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6172       aType == HYPOTHESIS || aType == ALGORITHM)
6173     return true;
6174
6175   return false;
6176 }
6177
6178 /*!
6179   Rename object by entry.
6180   \param entry entry of the object
6181   \param name new name of the object
6182   \brief Return \c true if rename operation finished successfully, \c false otherwise.
6183 */
6184 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6185
6186   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6187   if( !anApp )
6188     return false;
6189
6190   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6191
6192   if(!appStudy)
6193     return false;
6194
6195   _PTR(Study) aStudy = appStudy->studyDS();
6196
6197   if(!aStudy)
6198     return false;
6199
6200   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6201   if ( aLocked ) {
6202     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6203     return false;
6204   }
6205
6206
6207   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6208   _PTR(GenericAttribute) anAttr;
6209   _PTR(AttributeName) aName;
6210   if ( obj ) {
6211     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6212       aName = anAttr;
6213       // check type to prevent renaming of inappropriate objects
6214       int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6215       if (aType == MESH || aType == GROUP ||
6216           aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6217           aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6218           aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6219           aType == HYPOTHESIS || aType == ALGORITHM) {
6220         if ( !name.isEmpty() ) {
6221           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6222
6223           // update name of group object and its actor
6224           Handle(SALOME_InteractiveObject) IObject =
6225             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6226
6227           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6228           if( !aGroupObject->_is_nil() ) {
6229             aGroupObject->SetName( qPrintable(name) );
6230             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6231               anActor->setName( qPrintable(name) );
6232           }
6233           return true;
6234         }
6235       }
6236     }
6237   }
6238   return false;
6239 }