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