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