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