src/SMESHGUI/SMESHGUI.cxx

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