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   }
4772
4773   // get all view currently opened in the study and connect their signals  to
4774   // the corresponding slots of the class.
4775   SUIT_Desktop* aDesk = study->application()->desktop();
4776   if ( aDesk ) {
4777     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4778     SUIT_ViewWindow* wnd;
4779     foreach ( wnd, wndList )
4780       connectView( wnd );
4781   }
4782
4783   return res;
4784 }
4785
4786 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4787 {
4788   setMenuShown( false );
4789   setToolShown( false );
4790
4791   EmitSignalCloseAllDialogs();
4792
4793   // Unset actions accelerator keys
4794   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4795
4796   return SalomeApp_Module::deactivateModule( study );
4797 }
4798
4799 void SMESHGUI::studyClosed( SUIT_Study* s )
4800 {
4801   if( !s )
4802     return;
4803   SMESH::RemoveVisuData( s->id() );
4804   SalomeApp_Module::studyClosed( s );
4805 }
4806
4807 void SMESHGUI::OnGUIEvent()
4808 {
4809   const QObject* obj = sender();
4810   if ( !obj || !obj->inherits( "QAction" ) )
4811     return;
4812   int id = actionId((QAction*)obj);
4813   if ( id != -1 )
4814     OnGUIEvent( id );
4815 }
4816
4817 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4818 {
4819   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4820   if ( CORBA::is_nil( myComponentSMESH ) )
4821     {
4822       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4823       if ( aStudy )
4824         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4825       return aGUI.myComponentSMESH;
4826     }
4827   if ( aStudy )
4828     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4829   return myComponentSMESH;
4830 }
4831
4832 QString SMESHGUI::engineIOR() const
4833 {
4834   CORBA::ORB_var anORB = getApp()->orb();
4835   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4836   return QString( anIOR.in() );
4837 }
4838
4839 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4840 {
4841   SalomeApp_Module::contextMenuPopup( client, menu, title );
4842   SALOME_ListIO lst;
4843   selectionMgr()->selectedObjects( lst );
4844   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4845     Handle(SALOME_InteractiveObject) io = lst.First();
4846     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4847     _PTR(Study) study = appStudy->studyDS();
4848     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4849     if ( obj ) {
4850       QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4851       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4852           aName.remove( (aName.length() - 1), 1 );
4853       title = aName;
4854     }
4855   }
4856 }
4857
4858 LightApp_Selection* SMESHGUI::createSelection() const
4859 {
4860   return new SMESHGUI_Selection();
4861 }
4862
4863 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4864 {
4865   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4866   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4867   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4868 }
4869
4870 void SMESHGUI::viewManagers( QStringList& list ) const
4871 {
4872   list.append( SVTK_Viewer::Type() );
4873 }
4874
4875 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4876 {
4877   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4878     SMESH::UpdateSelectionProp( this );
4879
4880     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4881     for(int i = 0; i < aViews.count() ; i++){
4882       SUIT_ViewWindow *sf = aViews[i];
4883       connectView( sf );
4884     }
4885   }
4886 }
4887
4888 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4889 {
4890   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4891     myClippingPlaneInfoMap.erase( theViewManager );
4892 }
4893
4894 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4895 {
4896   theActor->AddObserver( SMESH::DeleteActorEvent,
4897                          myEventCallbackCommand.GetPointer(),
4898                          myPriority );
4899 }
4900
4901 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4902                               unsigned long theEvent,
4903                               void* theClientData,
4904                               void* theCallData )
4905 {
4906   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4907     if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4908       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4909         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4910         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4911         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4912           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4913           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4914           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4915             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4916             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4917             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4918             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4919               if( anActor == *anIter3 ) {
4920                 anActorList.erase( anIter3 );
4921                 break;
4922               }
4923             }
4924           }
4925         }
4926       }
4927     }
4928   }
4929 }
4930
4931 void SMESHGUI::createPreferences()
4932 {
4933   // General tab ------------------------------------------------------------------------
4934   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4935
4936   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4937   setPreferenceProperty( autoUpdate, "columns", 2 );
4938   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4939   setPreferenceProperty( lim, "min",  0 );
4940   setPreferenceProperty( lim, "max",  100000000 );
4941   setPreferenceProperty( lim, "step", 1000 );
4942   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4943   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4944
4945   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4946   setPreferenceProperty( qaGroup, "columns", 2 );
4947   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4948   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4949   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4950   setPreferenceProperty( prec, "min", 0 );
4951   setPreferenceProperty( prec, "max", 100 );
4952   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4953   setPreferenceProperty( doubleNodesTol, "precision", 10 );
4954   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4955   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4956   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4957
4958   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4959   setPreferenceProperty( dispgroup, "columns", 2 );
4960   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4961   QStringList modes;
4962   modes.append( tr("MEN_WIRE") );
4963   modes.append( tr("MEN_SHADE") );
4964   modes.append( tr("MEN_NODES") );
4965   modes.append( tr("MEN_SHRINK") );
4966   QList<QVariant> indices;
4967   indices.append( 0 );
4968   indices.append( 1 );
4969   indices.append( 2 );
4970   indices.append( 3 );
4971   setPreferenceProperty( dispmode, "strings", modes );
4972   setPreferenceProperty( dispmode, "indexes", indices );
4973
4974   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4975   setPreferenceProperty( arcgroup, "columns", 2 );
4976   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4977   QStringList quadraticModes;
4978   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4979   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4980   indices.clear();
4981   indices.append( 0 );
4982   indices.append( 1 );
4983   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4984   setPreferenceProperty( quadraticmode, "indexes", indices );
4985
4986   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4987                               "SMESH", "max_angle" );
4988   setPreferenceProperty( maxAngle, "min", 1 );
4989   setPreferenceProperty( maxAngle, "max", 90 );
4990
4991
4992
4993   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4994   setPreferenceProperty( exportgroup, "columns", 2 );
4995   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4996   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4997
4998   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4999   setPreferenceProperty( computeGroup, "columns", 2 );
5000   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5001   modes.clear();
5002   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5003   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5004   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5005   indices.clear();
5006   indices.append( 0 );
5007   indices.append( 1 );
5008   indices.append( 2 );
5009   setPreferenceProperty( notifyMode, "strings", modes );
5010   setPreferenceProperty( notifyMode, "indexes", indices );
5011
5012   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5013   setPreferenceProperty( infoGroup, "columns", 2 );
5014   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5015   modes.clear();
5016   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5017   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5018   indices.clear();
5019   indices.append( 0 );
5020   indices.append( 1 );
5021   setPreferenceProperty( elemInfo, "strings", modes );
5022   setPreferenceProperty( elemInfo, "indexes", indices );
5023   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5024   setPreferenceProperty( nodesLim, "min", 0 );
5025   setPreferenceProperty( nodesLim, "max", 10000000 );
5026   setPreferenceProperty( nodesLim, "step", 10000 );
5027   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5028   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5029   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5030   setPreferenceProperty( ctrlLim, "min", 0 );
5031   setPreferenceProperty( ctrlLim, "max", 10000000 );
5032   setPreferenceProperty( ctrlLim, "step", 1000 );
5033   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5034   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5035   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5036   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5037   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5038
5039   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5040   setPreferenceProperty( segGroup, "columns", 2 );
5041   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5042                               "SMESH", "segmentation" );
5043   setPreferenceProperty( segLen, "min", 1 );
5044   setPreferenceProperty( segLen, "max", 10000000 );
5045   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5046                              "SMESH", "nb_segments_per_edge" );
5047   setPreferenceProperty( nbSeg, "min", 1 );
5048   setPreferenceProperty( nbSeg, "max", 10000000 );
5049
5050   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5051   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5052                  "SMESH", "forget_mesh_on_hyp_modif" );
5053
5054
5055   // Quantities with individual precision settings
5056   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5057   setPreferenceProperty( precGroup, "columns", 2 );
5058
5059   const int nbQuantities = 6;
5060   int precs[nbQuantities], ii = 0;
5061   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5062                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5063   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5064                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5065   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5066                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5067   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5068                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5069   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5070                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5071   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5072                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5073
5074   // Set property for precision value for spinboxes
5075   for ( ii = 0; ii < nbQuantities; ii++ ){
5076     setPreferenceProperty( precs[ii], "min", -14 );
5077     setPreferenceProperty( precs[ii], "max", 14 );
5078     setPreferenceProperty( precs[ii], "precision", 2 );
5079   }
5080
5081   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5082   setPreferenceProperty( previewGroup, "columns", 2 );
5083   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5084   setPreferenceProperty( chunkSize, "min",  1 );
5085   setPreferenceProperty( chunkSize, "max",  1000 );
5086   setPreferenceProperty( chunkSize, "step", 50 );
5087
5088   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5089   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5090
5091   // Mesh tab ------------------------------------------------------------------------
5092   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5093   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5094   setPreferenceProperty( nodeGroup, "columns", 3 );
5095
5096   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5097
5098   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5099
5100   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5101   QList<QVariant> aMarkerTypeIndicesList;
5102   QList<QVariant> aMarkerTypeIconsList;
5103   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5104     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5105     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5106     aMarkerTypeIndicesList << i;
5107     aMarkerTypeIconsList << pixmap;
5108   }
5109   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5110   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5111
5112   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5113
5114   QList<QVariant> aMarkerScaleIndicesList;
5115   QStringList     aMarkerScaleValuesList;
5116   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5117     aMarkerScaleIndicesList << i;
5118     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5119   }
5120   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5121   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5122
5123   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5124   //setPreferenceProperty( elemGroup, "columns", 2 );
5125
5126   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5127   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5128   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5129   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5130   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5131   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5132   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5133   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5134   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5135
5136
5137   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5138   setPreferenceProperty( grpGroup, "columns", 2 );
5139
5140   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5141   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5142
5143   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5144                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5145   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5146                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5147   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5148                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5149   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5150                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5151   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5152                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5153   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5154                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5155   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5156                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5157
5158   setPreferenceProperty( size0d, "min", 1 );
5159   setPreferenceProperty( size0d, "max", 10 );
5160
5161  // setPreferenceProperty( ballSize, "min", 1 );
5162  // setPreferenceProperty( ballSize, "max", 10 );
5163
5164   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5165   setPreferenceProperty( ballDiameter, "max", 1e9 );
5166   setPreferenceProperty( ballDiameter, "step", 0.1 );
5167
5168   setPreferenceProperty( ballScale, "min", 1e-2 );
5169   setPreferenceProperty( ballScale, "max", 1e7 );
5170   setPreferenceProperty( ballScale, "step", 0.5 );
5171
5172   setPreferenceProperty( elemW, "min", 1 );
5173   setPreferenceProperty( elemW, "max", 5 );
5174
5175   setPreferenceProperty( outW, "min", 1 );
5176   setPreferenceProperty( outW, "max", 5 );
5177
5178   setPreferenceProperty( shrink, "min", 0 );
5179   setPreferenceProperty( shrink, "max", 100 );
5180
5181   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5182   setPreferenceProperty( numGroup, "columns", 2 );
5183
5184   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5185   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5186
5187   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5188   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5189
5190   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5191   setPreferenceProperty( orientGroup, "columns", 1 );
5192
5193   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5194   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5195
5196   setPreferenceProperty( orientScale, "min", 0.05 );
5197   setPreferenceProperty( orientScale, "max", 0.5 );
5198   setPreferenceProperty( orientScale, "step", 0.05 );
5199
5200   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5201
5202   // Selection tab ------------------------------------------------------------------------
5203   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5204
5205   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5206   setPreferenceProperty( selGroup, "columns", 2 );
5207
5208   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5209   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5210
5211   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5212   setPreferenceProperty( preGroup, "columns", 2 );
5213
5214   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5215
5216   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5217   setPreferenceProperty( precSelGroup, "columns", 2 );
5218
5219   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5220   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5221   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5222
5223   // Scalar Bar tab ------------------------------------------------------------------------
5224   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5225   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5226   setPreferenceProperty( fontGr, "columns", 2 );
5227
5228   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5229   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5230
5231   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5232   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5233
5234   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5235   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5236
5237   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5238   setPreferenceProperty( numcol, "min", 2 );
5239   setPreferenceProperty( numcol, "max", 256 );
5240
5241   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5242   setPreferenceProperty( numlab, "min", 2 );
5243   setPreferenceProperty( numlab, "max", 65 );
5244
5245   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5246   setPreferenceProperty( orientGr, "columns", 2 );
5247   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5248   QStringList orients;
5249   orients.append( tr( "SMESH_VERTICAL" ) );
5250   orients.append( tr( "SMESH_HORIZONTAL" ) );
5251   indices.clear(); indices.append( 0 ); indices.append( 1 );
5252   setPreferenceProperty( orient, "strings", orients );
5253   setPreferenceProperty( orient, "indexes", indices );
5254
5255   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5256   setPreferenceProperty( posVSizeGr, "columns", 2 );
5257   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5258   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5259   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5260   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5261   setPreferenceProperty( xv, "step", 0.1 );
5262   setPreferenceProperty( xv, "min", 0.0 );
5263   setPreferenceProperty( xv, "max", 1.0 );
5264   setPreferenceProperty( yv, "step", 0.1 );
5265   setPreferenceProperty( yv, "min", 0.0 );
5266   setPreferenceProperty( yv, "max", 1.0 );
5267   setPreferenceProperty( wv, "step", 0.1 );
5268   setPreferenceProperty( wv, "min", 0.0 );
5269   setPreferenceProperty( wv, "max", 1.0 );
5270   setPreferenceProperty( hv, "min", 0.0 );
5271   setPreferenceProperty( hv, "max", 1.0 );
5272   setPreferenceProperty( hv, "step", 0.1 );
5273
5274   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5275   setPreferenceProperty( posHSizeGr, "columns", 2 );
5276   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5277   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5278   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5279   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5280   setPreferenceProperty( xv, "min", 0.0 );
5281   setPreferenceProperty( xv, "max", 1.0 );
5282   setPreferenceProperty( xv, "step", 0.1 );
5283   setPreferenceProperty( xh, "min", 0.0 );
5284   setPreferenceProperty( xh, "max", 1.0 );
5285   setPreferenceProperty( xh, "step", 0.1 );
5286   setPreferenceProperty( yh, "min", 0.0 );
5287   setPreferenceProperty( yh, "max", 1.0 );
5288   setPreferenceProperty( yh, "step", 0.1 );
5289   setPreferenceProperty( wh, "min", 0.0 );
5290   setPreferenceProperty( wh, "max", 1.0 );
5291   setPreferenceProperty( wh, "step", 0.1 );
5292   setPreferenceProperty( hh, "min", 0.0 );
5293   setPreferenceProperty( hh, "max", 1.0 );
5294   setPreferenceProperty( hh, "step", 0.1 );
5295
5296   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5297   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5298   setPreferenceProperty( distributionGr, "columns", 3 );
5299   QStringList types;
5300   types.append( tr( "SMESH_MONOCOLOR" ) );
5301   types.append( tr( "SMESH_MULTICOLOR" ) );
5302   indices.clear(); indices.append( 0 ); indices.append( 1 );
5303   setPreferenceProperty( coloringType, "strings", types );
5304   setPreferenceProperty( coloringType, "indexes", indices );
5305   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5306
5307 }
5308
5309 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5310 {
5311   if( sect=="SMESH" ) {
5312     float sbX1,sbY1,sbW,sbH;
5313     float aTol = 1.00000009999999;
5314     std::string aWarning;
5315     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5316     if( name=="selection_object_color" || name=="selection_element_color" ||
5317         name=="highlight_color" ||
5318         name=="selection_precision_node" || name=="selection_precision_element" ||
5319         name=="selection_precision_object")
5320       SMESH::UpdateSelectionProp( this );
5321     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5322       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5323       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5324       if(sbX1+sbW > aTol){
5325         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5326         sbX1=0.01;
5327         sbW=0.08;
5328         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5329         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5330       }
5331     }
5332     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5333       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5334       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5335       if(sbY1+sbH > aTol){
5336         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5337         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5338         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5339       }
5340     }
5341     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
5342       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5343       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5344       if(sbX1+sbW > aTol){
5345         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5346         sbX1=0.1;
5347         sbW=0.08;
5348         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5349         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5350       }
5351     }
5352     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
5353       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5354       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5355       if(sbY1+sbH > aTol){
5356         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5357         sbY1=0.01;
5358         sbH=0.08;
5359         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5360         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5361       }
5362     }
5363     else if ( name == "segmentation" ) {
5364       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5365       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5366     }
5367     else if ( name == "nb_segments_per_edge" ) {
5368       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5369       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5370     }
5371     else if ( name == "historical_python_dump" ||
5372               name == "forget_mesh_on_hyp_modif") {
5373       QString val = aResourceMgr->stringValue( "SMESH", name );
5374       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5375     }
5376     else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5377       SMESH::UpdateFontProp( this );
5378     }
5379     else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5380       SMESH::UpdateFontProp( this );
5381     }
5382
5383     if(aWarning.size() != 0){
5384       aWarning += "The default values are applied instead.";
5385       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5386                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5387                                QObject::tr(aWarning.c_str()));
5388     }
5389   }
5390 }
5391
5392 //================================================================================
5393 /*!
5394  * \brief Update something in accordance with update flags
5395   * \param theFlags - update flags
5396 *
5397 * Update viewer or/and object browser etc. in accordance with update flags ( see
5398 * LightApp_UpdateFlags enumeration ).
5399 */
5400 //================================================================================
5401 void SMESHGUI::update( const int flags )
5402 {
5403   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5404     SMESH::UpdateView();
5405   else
5406     SalomeApp_Module::update( flags );
5407 }
5408
5409 //================================================================================
5410 /*!
5411  * \brief Set default selection mode
5412 *
5413 * SLOT called when operation commited. Sets default selection mode
5414 */
5415 //================================================================================
5416 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5417 {
5418   SVTK_ViewWindow* vtkWnd =
5419     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5420   if ( vtkWnd )
5421     vtkWnd->SetSelectionMode( ActorSelection );
5422 }
5423
5424 //================================================================================
5425 /*!
5426  * \brief Set default selection mode
5427 *
5428 * SLOT called when operation aborted. Sets default selection mode
5429 */
5430 //================================================================================
5431 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5432 {
5433   SVTK_ViewWindow* vtkWnd =
5434     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5435   if ( vtkWnd )
5436     vtkWnd->SetSelectionMode( ActorSelection );
5437 }
5438
5439 //================================================================================
5440 /*!
5441  * \brief Creates operation with given identifier
5442   * \param id - identifier of operation to be started
5443   * \return Pointer on created operation or NULL if operation is not created
5444 *
5445 * Virtual method redefined from the base class creates operation with given id.
5446 * It is called called automatically from startOperation method of base class.
5447 */
5448 //================================================================================
5449 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5450 {
5451   LightApp_Operation* op = 0;
5452   // to do : create operation here
5453   switch( id )
5454   {
5455     case SMESHOp::OpConvertMeshToQuadratic:
5456       op = new SMESHGUI_ConvToQuadOp();
5457     break;
5458     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5459       op = new SMESHGUI_Make2DFrom3DOp();
5460     break;
5461     case SMESHOp::OpReorientFaces:
5462       op = new SMESHGUI_ReorientFacesOp();
5463       break;
5464     case SMESHOp::OpCreateMesh:
5465       op = new SMESHGUI_MeshOp( true, true );
5466     break;
5467     case SMESHOp::OpCreateSubMesh:
5468       op = new SMESHGUI_MeshOp( true, false );
5469     break;
5470     case SMESHOp::OpEditMeshOrSubMesh:
5471       op = new SMESHGUI_MeshOp( false );
5472     break;
5473     case SMESHOp::OpCompute:
5474       op = new SMESHGUI_ComputeOp();
5475     break;
5476     case SMESHOp::OpPreCompute:
5477       op = new SMESHGUI_PrecomputeOp();
5478     break;
5479     case SMESHOp::OpEvaluate:
5480       op = new SMESHGUI_EvaluateOp();
5481     break;
5482     case SMESHOp::OpMeshOrder:
5483       op = new SMESHGUI_MeshOrderOp();
5484     break;
5485     case SMESHOp::OpCreateGeometryGroup:
5486       op = new SMESHGUI_GroupOnShapeOp();
5487       break;
5488     case SMESHOp::OpFindElementByPoint:
5489       op = new SMESHGUI_FindElemByPointOp();
5490       break;
5491     case SMESHOp::OpMoveNode: // Make mesh pass through point
5492       op = new SMESHGUI_MakeNodeAtPointOp();
5493       break;
5494     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5495       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5496       break;
5497     default:
5498     break;
5499   }
5500
5501   if( !op )
5502     op = SalomeApp_Module::createOperation( id );
5503   return op;
5504 }
5505
5506 //================================================================================
5507 /*!
5508  * \brief Stops current operations and starts a given one
5509   * \param id - The id of the operation to start
5510  */
5511 //================================================================================
5512
5513 void SMESHGUI::switchToOperation(int id)
5514 {
5515   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5516     activeStudy()->abortAllOperations();
5517   startOperation( id );
5518 }
5519
5520 LightApp_Displayer* SMESHGUI::displayer()
5521 {
5522   if( !myDisplayer )
5523     myDisplayer = new SMESHGUI_Displayer( getApp() );
5524   return myDisplayer;
5525 }
5526
5527 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5528 {
5529   int aHue = -1;
5530   int aTolerance = 64;
5531   int anIterations = 0;
5532   int aPeriod = 5;
5533
5534   while( 1 )
5535   {
5536     anIterations++;
5537     if( anIterations % aPeriod == 0 )
5538     {
5539       aTolerance /= 2;
5540       if( aTolerance < 1 )
5541         break;
5542     }
5543
5544     aHue = (int)( 360.0 * rand() / RAND_MAX );
5545
5546     bool ok = true;
5547     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5548     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5549     for( ; it != itEnd; ++it )
5550     {
5551       SALOMEDS::Color anAutoColor = *it;
5552       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5553
5554       int h, s, v;
5555       aQColor.getHsv( &h, &s, &v );
5556       if( abs( h - aHue ) < aTolerance )
5557       {
5558         ok = false;
5559         break;
5560       }
5561     }
5562
5563     if( ok )
5564       break;
5565   }
5566
5567   QColor aColor;
5568   aColor.setHsv( aHue, 255, 255 );
5569
5570   SALOMEDS::Color aSColor;
5571   aSColor.R = aColor.redF();
5572   aSColor.G = aColor.greenF();
5573   aSColor.B = aColor.blueF();
5574
5575   return aSColor;
5576 }
5577
5578 const char* gSeparator = "_"; // character used to separate parameter names
5579 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5580 const char* gPathSep   = "|"; // character used to separate paths
5581
5582 /*!
5583  * \brief Store visual parameters
5584  *
5585  * This method is called just before the study document is saved.
5586  * Store visual parameters in AttributeParameter attribue(s)
5587  */
5588 void SMESHGUI::storeVisualParameters (int savePoint)
5589 {
5590   // localizing
5591   Kernel_Utils::Localizer loc;
5592
5593   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5594   if (!appStudy || !appStudy->studyDS())
5595     return;
5596   _PTR(Study) studyDS = appStudy->studyDS();
5597
5598   // componentName is used for encoding of entries when storing them in IParameters
5599   std::string componentName = myComponentSMESH->ComponentDataType();
5600   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5601   //if (!aSComponent) return;
5602
5603   // IParameters
5604   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5605                                                              componentName.c_str(),
5606                                                              savePoint);
5607   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5608
5609   // store map of custom markers
5610   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5611   if( !aMarkerMap.empty() )
5612   {
5613     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5614     for( ; anIter != aMarkerMap.end(); anIter++ )
5615     {
5616       int anId = anIter->first;
5617       VTK::MarkerData aMarkerData = anIter->second;
5618       std::string aMarkerFileName = aMarkerData.first;
5619       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5620       if( aMarkerTexture.size() < 3 )
5621         continue; // should contain at least width, height and the first value
5622
5623       QString aPropertyName( "texture" );
5624       aPropertyName += gSeparator;
5625       aPropertyName += QString::number( anId );
5626
5627       QString aPropertyValue = aMarkerFileName.c_str();
5628       aPropertyValue += gPathSep;
5629
5630       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5631       ushort aWidth = *aTextureIter++;
5632       ushort aHeight = *aTextureIter++;
5633       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5634       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5635       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5636         aPropertyValue += QString::number( *aTextureIter );
5637
5638       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5639     }
5640   }
5641
5642   // viewers counters are used for storing view_numbers in IParameters
5643   int vtkViewers = 0;
5644
5645   // main cycle to store parameters of displayed objects
5646   QList<SUIT_ViewManager*> lst;
5647   QList<SUIT_ViewManager*>::Iterator it;
5648   getApp()->viewManagers(lst);
5649   for (it = lst.begin(); it != lst.end(); it++)
5650   {
5651     SUIT_ViewManager* vman = *it;
5652     QString vType = vman->getType();
5653
5654     // saving VTK actors properties
5655     if (vType == SVTK_Viewer::Type())
5656     {
5657       // store the clipping planes attached to the view manager
5658       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5659       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5660       if( anIter != myClippingPlaneInfoMap.end() )
5661         aClippingPlaneInfoList = anIter->second;
5662
5663       if( !aClippingPlaneInfoList.empty() ) {
5664         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5665         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5666         {
5667           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5668           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5669
5670           QString aPropertyName( "ClippingPlane" );
5671           aPropertyName += gSeparator;
5672           aPropertyName += QString::number( vtkViewers );
5673           aPropertyName += gSeparator;
5674           aPropertyName += QString::number( anId );
5675
5676           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5677           aPropertyValue += gDigitsSep;
5678           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5679           aPropertyValue += gDigitsSep;
5680           if ( aPlane->PlaneMode == SMESH::Absolute ) {
5681             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5682             aPropertyValue += gDigitsSep;
5683             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5684             aPropertyValue += gDigitsSep;
5685             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5686             aPropertyValue += gDigitsSep;
5687             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5688             aPropertyValue += gDigitsSep;
5689             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5690             aPropertyValue += gDigitsSep;
5691             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5692             aPropertyValue += gDigitsSep;
5693             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5694           }
5695           else if ( aPlane->PlaneMode == SMESH::Relative ) {
5696             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5697             aPropertyValue += gDigitsSep;
5698             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5699             aPropertyValue += gDigitsSep;
5700             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5701             aPropertyValue += gDigitsSep;
5702             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5703           }
5704
5705           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5706         }
5707       }
5708
5709       QVector<SUIT_ViewWindow*> views = vman->getViews();
5710       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5711       {
5712         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5713         {
5714           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5715           vtkActorCollection* allActors = aCopy.GetActors();
5716           allActors->InitTraversal();
5717           while (vtkActor* actor = allActors->GetNextActor())
5718           {
5719             if (actor->GetVisibility()) // store only visible actors
5720             {
5721               SMESH_Actor* aSmeshActor = 0;
5722               if (actor->IsA("SMESH_Actor"))
5723                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5724               if (aSmeshActor && aSmeshActor->hasIO())
5725               {
5726                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5727                 if (io->hasEntry())
5728                 {
5729                   // entry is "encoded" = it does NOT contain component adress,
5730                   // since it is a subject to change on next component loading
5731                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5732
5733                   std::string param, vtkParam = vType.toLatin1().data();
5734                   vtkParam += gSeparator;
5735                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5736                   vtkParam += gSeparator;
5737
5738                   // Visibility
5739                   param = vtkParam + "Visibility";
5740                   ip->setParameter(entry, param, "On");
5741
5742                   // Representation
5743                   param = vtkParam + "Representation";
5744                   ip->setParameter(entry, param, QString::number
5745                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5746
5747                   // IsShrunk
5748                   param = vtkParam + "IsShrunk";
5749                   ip->setParameter(entry, param, QString::number
5750                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5751
5752                   // Displayed entities
5753                   unsigned int aMode = aSmeshActor->GetEntityMode();
5754                   bool isE  = aMode & SMESH_Actor::eEdges;
5755                   bool isF  = aMode & SMESH_Actor::eFaces;
5756                   bool isV  = aMode & SMESH_Actor::eVolumes;
5757                   bool is0d = aMode & SMESH_Actor::e0DElements;
5758                   bool isB  = aMode & SMESH_Actor::eBallElem;
5759
5760                   QString modeStr ("e");
5761                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5762                   modeStr += gDigitsSep; modeStr += "f";
5763                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5764                   modeStr += gDigitsSep; modeStr += "v";
5765                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5766                   modeStr += gDigitsSep; modeStr += "0d";
5767                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5768                   modeStr += gDigitsSep; modeStr += "b";
5769                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5770
5771                   param = vtkParam + "Entities";
5772                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5773
5774                   // Colors
5775                   double r, g, b;
5776                   int delta;
5777
5778                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5779                   QStringList colorStr;
5780                   colorStr << "surface";
5781                   colorStr << QString::number(r);
5782                   colorStr << QString::number(g);
5783                   colorStr << QString::number(b);
5784
5785                   colorStr << "backsurface";
5786                   colorStr << QString::number(delta);
5787
5788                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5789                   colorStr << "volume";
5790                   colorStr << QString::number(r);
5791                   colorStr << QString::number(g);
5792                   colorStr << QString::number(b);
5793                   colorStr << QString::number(delta);
5794
5795                   aSmeshActor->GetEdgeColor(r, g, b);
5796                   colorStr << "edge";
5797                   colorStr << QString::number(r);
5798                   colorStr << QString::number(g);
5799                   colorStr << QString::number(b);
5800
5801                   aSmeshActor->GetNodeColor(r, g, b);
5802                   colorStr << "node";
5803                   colorStr << QString::number(r);
5804                   colorStr << QString::number(g);
5805                   colorStr << QString::number(b);
5806
5807                   aSmeshActor->GetOutlineColor(r, g, b);
5808                   colorStr << "outline";
5809                   colorStr << QString::number(r);
5810                   colorStr << QString::number(g);
5811                   colorStr << QString::number(b);
5812
5813                   aSmeshActor->Get0DColor(r, g, b);
5814                   colorStr << "elem0d";
5815                   colorStr << QString::number(r);
5816                   colorStr << QString::number(g);
5817                   colorStr << QString::number(b);
5818
5819                   aSmeshActor->GetBallColor(r, g, b);
5820                   colorStr << "ball";
5821                   colorStr << QString::number(r);
5822                   colorStr << QString::number(g);
5823                   colorStr << QString::number(b);
5824
5825                   aSmeshActor->GetFacesOrientationColor(r, g, b);
5826                   colorStr << "orientation";
5827                   colorStr << QString::number(r);
5828                   colorStr << QString::number(g);
5829                   colorStr << QString::number(b);
5830
5831                   param = vtkParam + "Colors";
5832                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5833
5834                   // Sizes
5835                   QStringList sizeStr;
5836                   sizeStr << "line";
5837                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5838                   sizeStr << "outline";
5839                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5840                   sizeStr << "elem0d";
5841                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5842                   sizeStr << "ball";
5843                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5844                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5845                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5846                   sizeStr << "shrink";
5847                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5848                   sizeStr << "orientation";
5849                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5850                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5851
5852                   param = vtkParam + "Sizes";
5853                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5854
5855                   // Point marker
5856                   QString markerStr;
5857
5858                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5859                   if( aMarkerType == VTK::MT_USER ) {
5860                     markerStr += "custom";
5861                     markerStr += gDigitsSep;
5862                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5863                   }
5864                   else {
5865                     markerStr += "std";
5866                     markerStr += gDigitsSep;
5867                     markerStr += QString::number( (int)aMarkerType );
5868                     markerStr += gDigitsSep;
5869                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5870                   }
5871
5872                   param = vtkParam + "PointMarker";
5873                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5874
5875                   // Opacity
5876                   param = vtkParam + "Opacity";
5877                   ip->setParameter(entry, param,
5878                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5879
5880                   // Clipping
5881                   param = vtkParam + "ClippingPlane";
5882                   int aPlaneId = 0;
5883                   if( !aClippingPlaneInfoList.empty() ) {
5884                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5885                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5886                     {
5887                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5888                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5889                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5890                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5891                         if( aSmeshActor == *anIter2 ) {
5892                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5893                                             QString::number( anId ).toLatin1().constData() );
5894                           break;
5895                         }
5896                       }
5897                     }
5898                   }
5899                   if( aPlaneId == 0 )
5900                     ip->setParameter( entry, param, "Off" );
5901                 } // if (io->hasEntry())
5902               } // SMESH_Actor && hasIO
5903             } // isVisible
5904           } // while.. actors traversal
5905         } // if (vtkView)
5906       } // for (views)
5907       vtkViewers++;
5908     } // if (SVTK view model)
5909   } // for (viewManagers)
5910 }
5911
5912 // data structures for clipping planes processing
5913 typedef struct {
5914   int Id;
5915   int Mode;
5916   bool isOpenGLClipping;
5917   vtkIdType RelativeOrientation;
5918   double Distance;
5919   double Angle[2];
5920   int AbsoluteOrientation;
5921   double X, Y, Z, Dx, Dy, Dz;
5922 } TPlaneData;
5923 typedef std::list<TPlaneData>         TPlaneDataList;
5924 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5925
5926 typedef std::list<vtkActor*>          TActorList;
5927 typedef struct {
5928   int PlaneId;
5929   TActorList ActorList;
5930   SUIT_ViewManager* ViewManager;
5931 } TPlaneInfo;
5932 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5933 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5934
5935 /*!
5936  * \brief Restore visual parameters
5937  *
5938  * This method is called after the study document is opened.
5939  * Restore visual parameters from AttributeParameter attribue(s)
5940  */
5941 void SMESHGUI::restoreVisualParameters (int savePoint)
5942 {
5943   // localizing
5944   Kernel_Utils::Localizer loc;
5945
5946   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5947   if (!appStudy || !appStudy->studyDS())
5948     return;
5949   _PTR(Study) studyDS = appStudy->studyDS();
5950
5951   // componentName is used for encoding of entries when storing them in IParameters
5952   std::string componentName = myComponentSMESH->ComponentDataType();
5953   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5954   //if (!aSComponent) return;
5955
5956   // IParameters
5957   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5958                                                              componentName.c_str(),
5959                                                              savePoint);
5960   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5961
5962   // restore map of custom markers and map of clipping planes
5963   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5964   TPlaneDataMap aPlaneDataMap;
5965
5966   std::vector<std::string> properties = ip->getProperties();
5967   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5968   {
5969     std::string property = *propIt;
5970     QString aPropertyName( property.c_str() );
5971     QString aPropertyValue( ip->getProperty( property ).c_str() );
5972
5973     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5974     if( aPropertyNameList.isEmpty() )
5975       continue;
5976
5977     QString aPropertyType = aPropertyNameList[0];
5978     if( aPropertyType == "texture" )
5979     {
5980       if( aPropertyNameList.size() != 2 )
5981         continue;
5982
5983       bool ok = false;
5984       int anId = aPropertyNameList[1].toInt( &ok );
5985       if( !ok || anId < 1 )
5986         continue;
5987
5988       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5989       if( aPropertyValueList.size() != 2 )
5990         continue;
5991
5992       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5993       QString aMarkerTextureString = aPropertyValueList[1];
5994       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5995       if( aMarkerTextureStringList.size() != 3 )
5996         continue;
5997
5998       ok = false;
5999       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6000       if( !ok )
6001         continue;
6002
6003       ok = false;
6004       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6005       if( !ok )
6006         continue;
6007
6008       VTK::MarkerTexture aMarkerTexture;
6009       aMarkerTexture.push_back( aWidth );
6010       aMarkerTexture.push_back( aHeight );
6011
6012       QString aMarkerTextureData = aMarkerTextureStringList[2];
6013       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6014       {
6015         QChar aChar = aMarkerTextureData.at( i );
6016         if( aChar.isDigit() )
6017           aMarkerTexture.push_back( aChar.digitValue() );
6018       }
6019
6020       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6021     }
6022     else if( aPropertyType == "ClippingPlane" )
6023     {
6024       if( aPropertyNameList.size() != 3 )
6025         continue;
6026
6027       bool ok = false;
6028       int aViewId = aPropertyNameList[1].toInt( &ok );
6029       if( !ok || aViewId < 0 )
6030         continue;
6031
6032       ok = false;
6033       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6034       if( !ok || aClippingPlaneId < 0 )
6035         continue;
6036
6037       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6038       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6039         continue;
6040
6041       TPlaneData aPlaneData;
6042       aPlaneData.Id = aClippingPlaneId;
6043
6044       ok = false;
6045       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6046       if( !ok )
6047         continue;
6048
6049       ok = false;
6050       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6051       if( !ok )
6052         continue;
6053
6054       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6055       {
6056         ok = false;
6057         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6058         if( !ok )
6059           continue;
6060
6061         ok = false;
6062         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6063         if( !ok )
6064           continue;
6065
6066         ok = false;
6067         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6068         if( !ok )
6069           continue;
6070
6071         ok = false;
6072         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6073         if( !ok )
6074           continue;
6075
6076         ok = false;
6077         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6078         if( !ok )
6079           continue;
6080
6081         ok = false;
6082         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6083         if( !ok )
6084           continue;
6085
6086         ok = false;
6087         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6088         if( !ok )
6089           continue;
6090       }
6091       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6092         ok = false;
6093         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6094         if( !ok )
6095           continue;
6096
6097         ok = false;
6098         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6099         if( !ok )
6100           continue;
6101
6102         ok = false;
6103         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6104         if( !ok )
6105           continue;
6106
6107         ok = false;
6108         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6109         if( !ok )
6110           continue;
6111       }
6112
6113       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6114       aPlaneDataList.push_back( aPlaneData );
6115     }
6116   }
6117
6118   TPlaneInfoMap aPlaneInfoMap;
6119
6120   std::vector<std::string> entries = ip->getEntries();
6121
6122   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6123   {
6124     // entry is a normal entry - it should be "decoded" (setting base adress of component)
6125     QString entry (ip->decodeEntry(*entIt).c_str());
6126
6127     // Check that the entry corresponds to a real object in the Study
6128     // as the object may be deleted or modified after the visual state is saved.
6129     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6130     if (!so) continue; //Skip the not existent entry
6131
6132     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6133     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6134
6135     std::vector<std::string>::iterator namesIt = paramNames.begin();
6136     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6137
6138     // actors are stored in a map after displaying of them for
6139     // quicker access in the future: map < viewID to actor >
6140     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6141
6142     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6143     {
6144       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6145       // '_' is used as separator and should not be used in viewer type or parameter names.
6146       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6147       if (lst.size() != 3)
6148         continue;
6149
6150       QString viewerTypStr = lst[0];
6151       QString viewIndexStr = lst[1];
6152       QString paramNameStr = lst[2];
6153
6154       bool ok;
6155       int viewIndex = viewIndexStr.toUInt(&ok);
6156       if (!ok) // bad conversion of view index to integer
6157         continue;
6158
6159       // viewers
6160       if (viewerTypStr == SVTK_Viewer::Type())
6161       {
6162         SMESH_Actor* aSmeshActor = 0;
6163         if (vtkActors.IsBound(viewIndex))
6164           aSmeshActor = vtkActors.Find(viewIndex);
6165
6166         QList<SUIT_ViewManager*> lst;
6167         getApp()->viewManagers(viewerTypStr, lst);
6168
6169         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6170         SUIT_ViewManager* vman = NULL;
6171         if (viewIndex >= 0 && viewIndex < lst.count())
6172           vman = lst.at(viewIndex);
6173
6174         if (paramNameStr == "Visibility")
6175         {
6176           if (!aSmeshActor && displayer() && vman)
6177           {
6178             SUIT_ViewModel* vmodel = vman->getViewModel();
6179             // SVTK view model can be casted to SALOME_View
6180             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6181
6182             // store displayed actor in a temporary map for quicker
6183             // access later when restoring other parameters
6184             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6185             vtkRenderer* Renderer = vtkView->getRenderer();
6186             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6187             vtkActorCollection* theActors = aCopy.GetActors();
6188             theActors->InitTraversal();
6189             bool isFound = false;
6190             vtkActor *ac = theActors->GetNextActor();
6191             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6192               if (ac->IsA("SMESH_Actor")) {
6193                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6194                 if (aGeomAc->hasIO()) {
6195                   Handle(SALOME_InteractiveObject) io =
6196                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6197                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6198                     isFound = true;
6199                     vtkActors.Bind(viewIndex, aGeomAc);
6200                   }
6201                 }
6202               }
6203             }
6204           }
6205         } // if (paramNameStr == "Visibility")
6206         else
6207         {
6208           // the rest properties "work" with SMESH_Actor
6209           if (aSmeshActor)
6210           {
6211             QString val ((*valuesIt).c_str());
6212
6213             // Representation
6214             if (paramNameStr == "Representation") {
6215               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6216             }
6217             // IsShrunk
6218             else if (paramNameStr == "IsShrunk") {
6219               if (val.toInt()) {
6220                 if (!aSmeshActor->IsShrunk())
6221                   aSmeshActor->SetShrink();
6222               }
6223               else {
6224                 if (aSmeshActor->IsShrunk())
6225                   aSmeshActor->UnShrink();
6226               }
6227             }
6228             // Displayed entities
6229             else if (paramNameStr == "Entities") {
6230               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6231               int aEntityMode = SMESH_Actor::eAllEntity;
6232               for ( int i = 0; i < mode.count(); i+=2 ) {
6233                 if ( i < mode.count()-1 ) {
6234                   QString type = mode[i];
6235                   bool val = mode[i+1].toInt();
6236                   if      ( type == "e" && !val )
6237                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6238                   else if ( type == "f" && !val )
6239                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6240                   else if ( type == "v" && !val )
6241                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6242                   else if ( type == "0d" && !val )
6243                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6244                   else if ( type == "b" && !val )
6245                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6246                 }
6247               }
6248               aSmeshActor->SetEntityMode( aEntityMode );
6249             }
6250             // Colors
6251             else if (paramNameStr == "Colors") {
6252               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6253               QColor nodeColor;
6254               QColor edgeColor;
6255               QColor faceColor;
6256               QColor volumeColor;
6257               QColor elem0dColor;
6258               QColor ballColor;
6259               QColor outlineColor;
6260               QColor orientationColor;
6261               int deltaF;
6262               int deltaV;
6263               QColor c;
6264               double r, g, b;
6265               bool bOk;
6266               // below lines are required to get default values for delta coefficients
6267               // of backface color for faces and color of reversed volumes
6268               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6269               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6270               for ( int i = 0; i < colors.count(); i++ ) {
6271                 QString type = colors[i];
6272                 if ( type == "surface" ) {
6273                   // face color is set by 3 values r:g:b, where
6274                   // - r,g,b - is rgb color components
6275                   if ( i+1 >= colors.count() ) break;                  // format error
6276                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6277                   if ( i+2 >= colors.count() ) break;                  // format error
6278                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6279                   if ( i+3 >= colors.count() ) break;                  // format error
6280                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6281                   faceColor.setRgbF( r, g, b );
6282                   i += 3;
6283                 }
6284                 else if ( type == "backsurface" ) {
6285                   // backface color can be defined in several ways
6286                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6287                   // - in latest versions, it is set as delta coefficient
6288                   bool rgbOk = false, deltaOk;
6289                   if ( i+1 >= colors.count() ) break;                  // format error
6290                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6291                   int delta = colors[i+1].toInt( &deltaOk );
6292                   i++;                                 // shift index
6293                   if ( i+1 < colors.count() )          // index is shifted to 1
6294                     g = colors[i+1].toDouble( &rgbOk );
6295                   if ( rgbOk ) i++;                    // shift index
6296                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6297                     b = colors[i+1].toDouble( &rgbOk );
6298                   if ( rgbOk ) i++;
6299                   // - as currently there's no way to set directly backsurface color as it was before,
6300                   // we ignore old dump where r,g,b triple was set
6301                   // - also we check that delta parameter is set properly
6302                   if ( !rgbOk && deltaOk )
6303                     deltaF = delta;
6304                 }
6305                 else if ( type == "volume" ) {
6306                   // volume color is set by 4 values r:g:b:delta, where
6307                   // - r,g,b - is a normal volume rgb color components
6308                   // - delta - is a reversed volume color delta coefficient
6309                   if ( i+1 >= colors.count() ) break;                  // format error
6310                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6311                   if ( i+2 >= colors.count() ) break;                  // format error
6312                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6313                   if ( i+3 >= colors.count() ) break;                  // format error
6314                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6315                   if ( i+4 >= colors.count() ) break;                  // format error
6316                   int delta = colors[i+4].toInt( &bOk );
6317                   if ( !bOk ) break;                                   // format error
6318                   volumeColor.setRgbF( r, g, b );
6319                   deltaV = delta;
6320                   i += 4;
6321                 }
6322                 else if ( type == "edge" ) {
6323                   // edge color is set by 3 values r:g:b, where
6324                   // - r,g,b - is rgb color components
6325                   if ( i+1 >= colors.count() ) break;                  // format error
6326                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6327                   if ( i+2 >= colors.count() ) break;                  // format error
6328                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6329                   if ( i+3 >= colors.count() ) break;                  // format error
6330                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6331                   edgeColor.setRgbF( r, g, b );
6332                   i += 3;
6333                 }
6334                 else if ( type == "node" ) {
6335                   // node color is set by 3 values r:g:b, where
6336                   // - r,g,b - is rgb color components
6337                   if ( i+1 >= colors.count() ) break;                  // format error
6338                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6339                   if ( i+2 >= colors.count() ) break;                  // format error
6340                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6341                   if ( i+3 >= colors.count() ) break;                  // format error
6342                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6343                   nodeColor.setRgbF( r, g, b );
6344                   i += 3;
6345                 }
6346                 else if ( type == "elem0d" ) {
6347                   // 0d element color is set by 3 values r:g:b, where
6348                   // - r,g,b - is rgb color components
6349                   if ( i+1 >= colors.count() ) break;                  // format error
6350                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6351                   if ( i+2 >= colors.count() ) break;                  // format error
6352                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6353                   if ( i+3 >= colors.count() ) break;                  // format error
6354                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6355                   elem0dColor.setRgbF( r, g, b );
6356                   i += 3;
6357                 }
6358                 else if ( type == "ball" ) {
6359                   // ball color is set by 3 values r:g:b, where
6360                   // - r,g,b - is rgb color components
6361                   if ( i+1 >= colors.count() ) break;                  // format error
6362                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6363                   if ( i+2 >= colors.count() ) break;                  // format error
6364                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6365                   if ( i+3 >= colors.count() ) break;                  // format error
6366                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6367                   ballColor.setRgbF( r, g, b );
6368                   i += 3;
6369                 }
6370                 else if ( type == "outline" ) {
6371                   // outline color is set by 3 values r:g:b, where
6372                   // - r,g,b - is rgb color components
6373                   if ( i+1 >= colors.count() ) break;                  // format error
6374                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6375                   if ( i+2 >= colors.count() ) break;                  // format error
6376                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6377                   if ( i+3 >= colors.count() ) break;                  // format error
6378                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6379                   outlineColor.setRgbF( r, g, b );
6380                   i += 3;
6381                 }
6382                 else if ( type == "orientation" ) {
6383                   // orientation color is set by 3 values r:g:b, where
6384                   // - r,g,b - is rgb color components
6385                   if ( i+1 >= colors.count() ) break;                  // format error
6386                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6387                   if ( i+2 >= colors.count() ) break;                  // format error
6388                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6389                   if ( i+3 >= colors.count() ) break;                  // format error
6390                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6391                   orientationColor.setRgbF( r, g, b );
6392                   i += 3;
6393                 }
6394               }
6395               // node color
6396               if ( nodeColor.isValid() )
6397                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6398               // edge color
6399               if ( edgeColor.isValid() )
6400                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6401               // face color
6402               if ( faceColor.isValid() )
6403                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6404               // volume color
6405               if ( volumeColor.isValid() )
6406                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6407               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6408                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6409               // 0d element color
6410               if ( elem0dColor.isValid() )
6411                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6412               // ball color
6413               if ( ballColor.isValid() )
6414                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6415               // outline color
6416               if ( outlineColor.isValid() )
6417                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6418               // orientation color
6419               if ( orientationColor.isValid() )
6420                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6421             }
6422             // Sizes
6423             else if (paramNameStr == "Sizes") {
6424               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6425               bool bOk;
6426               int lineWidth = -1;
6427               int outlineWidth = -1;
6428               int elem0dSize = -1;
6429               //int ballSize = -1;
6430               double ballDiameter = -1.0;
6431               double ballScale = -1.0;
6432               double shrinkSize = -1;
6433               double orientationSize = -1;
6434               bool orientation3d = false;
6435               for ( int i = 0; i < sizes.count(); i++ ) {
6436                 QString type = sizes[i];
6437                 if ( type == "line" ) {
6438                   // line (wireframe) width is given as single integer value
6439                   if ( i+1 >= sizes.count() ) break;                    // format error
6440                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6441                   lineWidth = v;
6442                   i++;
6443                 }
6444                 if ( type == "outline" ) {
6445                   // outline width is given as single integer value
6446                   if ( i+1 >= sizes.count() ) break;                    // format error
6447                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6448                   outlineWidth = v;
6449                   i++;
6450                 }
6451                 else if ( type == "elem0d" ) {
6452                   // 0d element size is given as single integer value
6453                   if ( i+1 >= sizes.count() ) break;                    // format error
6454                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6455                   elem0dSize = v;
6456                   i++;
6457                 }
6458                 else if ( type == "ball" ) {
6459                   // balls are specified by two values: size:scale, where
6460                   // - size - is a integer value specifying size
6461                   // - scale - is a double value specifying scale factor
6462                   if ( i+1 >= sizes.count() ) break;                       // format error
6463                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6464                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6465                   if ( i+2 >= sizes.count() ) break;                       // format error
6466                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6467                   //ballSize = v1;
6468                   ballDiameter = v1;
6469                   ballScale = v2;
6470                   i += 2;
6471                 }
6472                 else if ( type == "shrink" ) {
6473                   // shrink factor is given as single floating point value
6474                   if ( i+1 >= sizes.count() ) break;                          // format error
6475                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6476                   shrinkSize = v;
6477                   i++;
6478                 }
6479                 else if ( type == "orientation" ) {
6480                   // orientation vectors are specified by two values size:3d, where
6481                   // - size - is a floating point value specifying scale factor
6482                   // - 3d - is a boolean
6483                   if ( i+1 >= sizes.count() ) break;                          // format error
6484                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6485                   if ( i+2 >= sizes.count() ) break;                          // format error
6486                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6487                   orientationSize = v1;
6488                   orientation3d = (bool)v2;
6489                   i += 2;
6490                 }
6491               }
6492               // line (wireframe) width
6493               if ( lineWidth > 0 )
6494                 aSmeshActor->SetLineWidth( lineWidth );
6495               // outline width
6496               if ( outlineWidth > 0 )
6497                 aSmeshActor->SetOutlineWidth( outlineWidth );
6498               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6499                 aSmeshActor->SetOutlineWidth( lineWidth );
6500               // 0d element size
6501               if ( elem0dSize > 0 )
6502                 aSmeshActor->Set0DSize( elem0dSize );
6503               // ball size
6504               /*if ( ballSize > 0 )
6505                 aSmeshActor->SetBallSize( ballSize );*/
6506               // ball diameter
6507               if ( ballDiameter > 0 )
6508                 aSmeshActor->SetBallSize( ballDiameter );
6509               // ball scale
6510               if ( ballScale > 0.0 )
6511                 aSmeshActor->SetBallScale( ballScale );
6512               // shrink factor
6513               if ( shrinkSize > 0 )
6514                 aSmeshActor->SetShrinkFactor( shrinkSize );
6515               // orientation vectors
6516               if ( orientationSize > 0 ) {
6517                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6518                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6519               }
6520             }
6521             // Point marker
6522             else if (paramNameStr == "PointMarker") {
6523               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6524               if( data.count() >= 2 ) {
6525                 bool ok = false;
6526                 int aParam1 = data[1].toInt( &ok );
6527                 if( ok ) {
6528                   if( data[0] == "std" && data.count() == 3 ) {
6529                     int aParam2 = data[2].toInt( &ok );
6530                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6531                   }
6532                   else if( data[0] == "custom" ) {
6533                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6534                     if( markerIt != aMarkerMap.end() ) {
6535                       VTK::MarkerData aMarkerData = markerIt->second;
6536                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6537                     }
6538                   }
6539                 }
6540               }
6541             }
6542             // Opacity
6543             else if (paramNameStr == "Opacity") {
6544               aSmeshActor->SetOpacity(val.toFloat());
6545             }
6546             // Clipping
6547             else if (paramNameStr.startsWith("ClippingPlane")) {
6548               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6549               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6550               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6551               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6552               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6553               // new format - val looks like "Off" or "0" (plane id)
6554               // (note: in new format "Off" value is used only for consistency,
6555               //  so it is processed together with values in old format)
6556               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6557               if( anIsOldFormat ) {
6558                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6559                   aSmeshActor->RemoveAllClippingPlanes();
6560                 if (val != "Off") {
6561                   QList<SUIT_ViewManager*> lst;
6562                   getApp()->viewManagers(viewerTypStr, lst);
6563                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6564                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6565                     SUIT_ViewManager* vman = lst.at(viewIndex);
6566                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6567
6568                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6569
6570                     SMESH::TActorList anActorList;
6571                     anActorList.push_back( aSmeshActor );
6572                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6573                     aPlane->myViewWindow = vtkView;
6574                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6575                     aPlane->PlaneMode = aMode;
6576                     bool isOpenGLClipping = ( bool )vals[1].toInt();
6577                     aPlane->IsOpenGLClipping = isOpenGLClipping;
6578                     if ( aMode == SMESH::Absolute ) {
6579                       aPlane->myAbsoluteOrientation = vals[2].toInt();
6580                       aPlane->X = vals[3].toFloat();
6581                       aPlane->Y = vals[4].toFloat();
6582                       aPlane->Z = vals[5].toFloat();
6583                       aPlane->Dx = vals[6].toFloat();
6584                       aPlane->Dy = vals[7].toFloat();
6585                       aPlane->Dz = vals[8].toFloat();
6586                     }
6587                     else if ( aMode == SMESH::Relative ) {
6588                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6589                       aPlane->myDistance = vals[3].toFloat();
6590                       aPlane->myAngle[0] = vals[4].toFloat();
6591                       aPlane->myAngle[1] = vals[5].toFloat();
6592                     }
6593
6594                     if( aPlane ) {
6595                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6596                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6597                         aClippingPlaneInfo.Plane = aPlane;
6598                         aClippingPlaneInfo.ActorList = anActorList;
6599                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6600                       }
6601                     }
6602                   }
6603                 }
6604               }
6605               else {
6606                 bool ok = false;
6607                 int aPlaneId = val.toInt( &ok );
6608                 if( ok && aPlaneId >= 0 ) {
6609                   bool anIsDefinedPlane = false;
6610                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6611                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6612                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6613                     TPlaneInfo& aPlaneInfo = *anIter;
6614                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6615                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6616                       anIsDefinedPlane = true;
6617                       break;
6618                     }
6619                   }
6620                   if( !anIsDefinedPlane ) {
6621                     TPlaneInfo aPlaneInfo;
6622                     aPlaneInfo.PlaneId = aPlaneId;
6623                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6624                     aPlaneInfo.ViewManager = vman;
6625
6626                     // to make the list sorted by plane id
6627                     anIter = aPlaneInfoList.begin();
6628                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6629                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6630                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6631                         break;
6632                     }
6633                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6634                   }
6635                 }
6636               }
6637             }
6638           } // if (aSmeshActor)
6639         } // other parameters than Visibility
6640       }
6641     } // for names/parameters iterator
6642   } // for entries iterator
6643
6644   // take into account planes with empty list of actors referred to them
6645   QList<SUIT_ViewManager*> aVMList;
6646   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6647
6648   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6649   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6650     int aViewId = aPlaneDataIter->first;
6651     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6652       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6653
6654       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6655
6656       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6657       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6658       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6659         const TPlaneData& aPlaneData = *anIter2;
6660         int aPlaneId = aPlaneData.Id;
6661
6662         bool anIsFound = false;
6663         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6664         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6665           const TPlaneInfo& aPlaneInfo = *anIter3;
6666           if( aPlaneInfo.PlaneId == aPlaneId ) {
6667             anIsFound = true;
6668             break;
6669           }
6670         }
6671
6672         if( !anIsFound ) {
6673           TPlaneInfo aPlaneInfo; // ActorList field is empty
6674           aPlaneInfo.PlaneId = aPlaneId;
6675           aPlaneInfo.ViewManager = aViewManager;
6676
6677           // to make the list sorted by plane id
6678           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6679           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6680             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6681             if( aPlaneInfoRef.PlaneId > aPlaneId )
6682               break;
6683           }
6684           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6685         }
6686       }
6687     }
6688   }
6689
6690   // add clipping planes to actors according to the restored parameters
6691   // and update the clipping plane map
6692   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6693   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6694     int aViewId = anIter1->first;
6695     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6696
6697     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6698     if( anIter2 == aPlaneDataMap.end() )
6699       continue;
6700     const TPlaneDataList& aPlaneDataList = anIter2->second;
6701
6702     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6703     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6704       const TPlaneInfo& aPlaneInfo = *anIter3;
6705       int aPlaneId = aPlaneInfo.PlaneId;
6706       const TActorList& anActorList = aPlaneInfo.ActorList;
6707       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6708       if( !aViewManager )
6709         continue;
6710
6711       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6712       if( !aViewWindow )
6713         continue;
6714
6715       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6716
6717       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6718       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6719         const TPlaneData& aPlaneData = *anIter4;
6720         if( aPlaneData.Id == aPlaneId ) {
6721           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6722           aPlane->myViewWindow = aViewWindow;
6723           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6724           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6725           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6726             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6727             aPlane->X = aPlaneData.X;
6728             aPlane->Y = aPlaneData.Y;
6729             aPlane->Z = aPlaneData.Z;
6730             aPlane->Dx = aPlaneData.Dx;
6731             aPlane->Dy = aPlaneData.Dy;
6732             aPlane->Dz = aPlaneData.Dz;
6733           }
6734           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6735             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6736             aPlane->myDistance = aPlaneData.Distance;
6737             aPlane->myAngle[0] = aPlaneData.Angle[0];
6738             aPlane->myAngle[1] = aPlaneData.Angle[1];
6739           }
6740           if( aPlane ) {
6741             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6742               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6743               aClippingPlaneInfo.Plane = aPlane;
6744               aClippingPlaneInfo.ActorList = anActorList;
6745               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6746             }
6747           }
6748           break;
6749         }
6750       }
6751
6752     }
6753   }
6754
6755
6756   // update all VTK views
6757   QList<SUIT_ViewManager*> lst;
6758   getApp()->viewManagers(lst);
6759   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6760     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6761     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6762       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6763       // set OpenGL clipping planes
6764       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6765       vtkActorCollection* anAllActors = aCopy.GetActors();
6766       anAllActors->InitTraversal();
6767       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6768         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6769           anActor->SetOpenGLClippingPlane();
6770
6771       vtkView->getRenderer()->ResetCameraClippingRange();
6772       vtkView->Repaint();
6773     }
6774   }
6775 }
6776
6777 /*!
6778   \brief Adds preferences for dfont of VTK viewer
6779   \param label label
6780   \param pIf group identifier
6781   \param param parameter
6782   \return identifier of preferences
6783 */
6784 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6785 {
6786   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6787
6788   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6789
6790   QStringList fam;
6791   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6792   fam.append( tr( "SMESH_FONT_COURIER" ) );
6793   fam.append( tr( "SMESH_FONT_TIMES" ) );
6794
6795   setPreferenceProperty( tfont, "fonts", fam );
6796
6797   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6798   if ( needSize ) f = f | QtxFontEdit::Size;
6799   setPreferenceProperty( tfont, "features", f );
6800
6801   return tfont;
6802 }
6803
6804 /*!
6805   \brief Actions after hypothesis edition
6806   Updates object browser after hypothesis edition
6807 */
6808 void SMESHGUI::onHypothesisEdit( int result )
6809 {
6810   if( result == 1 )
6811     SMESHGUI::Modified();
6812   updateObjBrowser( true );
6813 }
6814
6815
6816 /*!
6817   \brief Signal handler closing(SUIT_ViewWindow*) of a view
6818   \param pview view being closed
6819 */
6820 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6821 #ifndef DISABLE_PLOT2DVIEWER
6822   //Crear all Plot2d Viewers if need.
6823   SMESH::ClearPlot2Viewers(pview);
6824 #endif
6825 }
6826
6827 void SMESHGUI::message( const QString& msg )
6828 {
6829   // dispatch message
6830   QStringList data = msg.split("/");
6831   if ( data.count() > 0 ) {
6832     if ( data.first() == "mesh_loading" ) {
6833       // get mesh entry
6834       QString entry = data.count() > 1 ? data[1] : QString();
6835       if ( entry.isEmpty() )
6836         return;
6837       // get study
6838       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6839       // get mesh name
6840       _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6841       QString name;
6842       if ( obj )
6843         name = SMESH::fromUtf8(obj->GetName());
6844       if ( name.isEmpty() )
6845         return;
6846
6847       if ( data.last() == "stop" )
6848         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6849       else
6850         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6851       QApplication::processEvents();
6852     }
6853   }
6854 }
6855
6856 /*!
6857   \brief Connects or disconnects signals about activating and cloning view on the module slots
6858   \param pview view which is connected/disconnected
6859 */
6860 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6861   if(!pview)
6862     return;
6863
6864   SUIT_ViewManager* viewMgr = pview->getViewManager();
6865   if ( viewMgr ) {
6866     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6867                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6868
6869     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6870              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6871   }
6872 }
6873
6874 /*!
6875   \brief Return \c true if object can be renamed
6876 */
6877 bool SMESHGUI::renameAllowed( const QString& entry) const {
6878   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6879   if( !anApp )
6880     return false;
6881
6882   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6883   if( !appStudy )
6884     return false;
6885
6886   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6887
6888   if(!obj)
6889     return false;
6890
6891   if(appStudy->isComponent(entry) || obj->isReference())
6892     return false;
6893
6894   // check type to prevent renaming of inappropriate objects
6895   int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6896   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6897       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6898       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6899       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6900       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6901     return true;
6902
6903   return false;
6904 }
6905
6906 /*!
6907   Rename object by entry.
6908   \param entry entry of the object
6909   \param name new name of the object
6910   \brief Return \c true if rename operation finished successfully, \c false otherwise.
6911 */
6912 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6913
6914   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6915   if( !anApp )
6916     return false;
6917
6918   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6919
6920   if(!appStudy)
6921     return false;
6922
6923   _PTR(Study) aStudy = appStudy->studyDS();
6924
6925   if(!aStudy)
6926     return false;
6927
6928   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6929   if ( aLocked ) {
6930     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6931     return false;
6932   }
6933
6934
6935   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6936   _PTR(GenericAttribute) anAttr;
6937   _PTR(AttributeName) aName;
6938   if ( obj ) {
6939     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6940       aName = anAttr;
6941       // check type to prevent renaming of inappropriate objects
6942       int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6943       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6944           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6945           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6946           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6947           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6948         if ( !name.isEmpty() ) {
6949           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6950
6951           // update name of group object and its actor
6952           Handle(SALOME_InteractiveObject) IObject =
6953             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6954
6955           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6956           if( !aGroupObject->_is_nil() ) {
6957             aGroupObject->SetName( qPrintable(name) );
6958             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6959               anActor->setName( qPrintable(name) );
6960           }
6961           return true;
6962         }
6963       }
6964     }
6965   }
6966   return false;
6967 }
6968
6969 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6970 {
6971   static QList<QColor> colors;
6972
6973   if ( colors.isEmpty() ) {
6974
6975     for (int s = 0; s < 2 ; s++)
6976     {
6977       for (int v = 100; v >= 40; v = v - 20)
6978       {
6979         for (int h = 0; h < 359 ; h = h + 60)
6980         {
6981           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6982         }
6983       }
6984     }
6985   }
6986   static int currentColor = randomize( colors.size() );
6987
6988   SALOMEDS::Color color;
6989   color.R = (double)colors[currentColor].red()   / 255.0;
6990   color.G = (double)colors[currentColor].green() / 255.0;
6991   color.B = (double)colors[currentColor].blue()  / 255.0;
6992
6993   currentColor = (currentColor+1) % colors.count();
6994
6995   return color;
6996 }